// Consolidated decompiled source — WackyMole-MistrootTamer v1.0.7
// Generated by Hexium's decompiled-source browser. Best-effort concatenation of every type in this
// version's manifest — decompiler output isn't guaranteed to compile as-is.

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

// ---- MistrootTamer.dll :: MistrootTamer.ParticleMistAwakePatch ----
namespace MistrootTamer
{
[HarmonyPatch(typeof(ParticleMist), "Awake")]
internal static class ParticleMistAwakePatch
{
	[<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(1)]
	[UsedImplicitly]
	private static void Postfix(ParticleMist __instance)
	{
		try
		{
			if (__instance != null && __instance.m_ps != null && __instance.gameObject.transform.root.gameObject.name.Replace("(Clone)", "") != "Mistroot")
			{
				UnityEngine.Object.DestroyImmediate(__instance.gameObject);
			}
		}
		catch (Exception data)
		{
			MistrootTamerPlugin.MistrootTamerLogger.LogError(data);
		}
	}
}

}


// ---- MistrootTamer.dll :: MistrootTamer.MistEmitterAwakePatch ----
namespace MistrootTamer
{
[HarmonyPatch(typeof(MistEmitter), "SetEmit")]
internal static class MistEmitterAwakePatch
{
	[<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(1)]
	private static void Prefix(MistEmitter __instance, ref bool emit)
	{
		try
		{
			if (__instance.gameObject.transform.root.gameObject.name.Replace("(Clone)", "") != "Mistroot")
			{
				UnityEngine.Object.DestroyImmediate(__instance.gameObject);
			}
		}
		catch (Exception data)
		{
			MistrootTamerPlugin.MistrootTamerLogger.LogError(data);
		}
	}
}

}


// ---- MistrootTamer.dll :: MistrootTamer.DestroyIfNotMistRootMisterAwakePatch ----
namespace MistrootTamer
{
[HarmonyPatch(typeof(Mister), "Awake")]
internal static class DestroyIfNotMistRootMisterAwakePatch
{
	[<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(1)]
	private static void Prefix(Mister __instance)
	{
		if (__instance.GetComponent<AzuMist>() == null)
		{
			__instance.enabled = false;
		}
	}
}

}


// ---- MistrootTamer.dll :: MistrootTamer.DisableIfNotMistRootMisterAwakePatch ----
namespace MistrootTamer
{
[HarmonyPatch(typeof(Mister), "OnEnable")]
internal static class DisableIfNotMistRootMisterAwakePatch
{
	[<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(1)]
	private static void Prefix(Mister __instance)
	{
		if (__instance.GetComponent<AzuMist>() == null)
		{
			__instance.enabled = false;
		}
	}
}

}


// ---- MistrootTamer.dll :: MistrootTamer.ZoneSystemValidatePatch ----
namespace MistrootTamer
{
[HarmonyPatch(typeof(ZoneSystem), "ValidateVegetation")]
internal static class ZoneSystemValidatePatch
{
	[<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(1)]
	private static void Prefix(ZoneSystem __instance)
	{
		GameObject prefab = ZNetScene.instance.GetPrefab("Mistroot");
		ZoneSystem.ZoneVegetation item = new ZoneSystem.ZoneVegetation
		{
			m_name = prefab.name,
			m_prefab = prefab,
			m_enable = true,
			m_max = 2f,
			m_forcePlacement = true,
			m_scaleMin = 1f,
			m_scaleMax = 1.75f,
			m_chanceToUseGroundTilt = 0f,
			m_biome = MistrootTamerPlugin.Biome.Value,
			m_biomeArea = Heightmap.BiomeArea.Everything,
			m_blockCheck = true,
			m_minAltitude = 0.01f,
			m_maxAltitude = 1000f,
			m_groupSizeMin = 1,
			m_groupSizeMax = 1,
			m_groupRadius = 6f,
			m_inForest = false,
			m_forestTresholdMin = 0f,
			m_forestTresholdMax = 1f,
			m_foldout = false
		};
		__instance.m_vegetation.Add(item);
	}
}

}


// ---- MistrootTamer.dll :: MistrootTamer.ZoneSystemStartPatch ----
namespace MistrootTamer
{
[HarmonyPatch(typeof(ZoneSystem), "Start")]
internal static class ZoneSystemStartPatch
{
	[<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(1)]
	[UsedImplicitly]
	private static void Prefix(ZoneSystem __instance)
	{
		GameObject prefab = ZNetScene.instance.GetPrefab("Mistroot");
		ZoneSystem.ZoneVegetation item = new ZoneSystem.ZoneVegetation
		{
			m_name = prefab.name,
			m_prefab = prefab,
			m_enable = true,
			m_max = 2f,
			m_forcePlacement = true,
			m_scaleMin = 1f,
			m_scaleMax = 1.75f,
			m_chanceToUseGroundTilt = 0f,
			m_biome = MistrootTamerPlugin.Biome.Value,
			m_biomeArea = Heightmap.BiomeArea.Everything,
			m_blockCheck = true,
			m_minAltitude = 0.01f,
			m_maxAltitude = 1000f,
			m_groupSizeMin = 1,
			m_groupSizeMax = 1,
			m_groupRadius = 6f,
			m_inForest = false,
			m_forestTresholdMin = 0f,
			m_forestTresholdMax = 1f,
			m_foldout = false
		};
		__instance.m_vegetation.Add(item);
	}
}

}


// ---- MistrootTamer.dll :: MistrootTamer.ZNetSceneAwakePatch ----
namespace MistrootTamer
{
[<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(1)]
[<e422f648-68ec-4aec-9a93-338e95589b99>Nullable(0)]
[HarmonyPatch(typeof(ZNetScene), "Awake")]
internal static class ZNetSceneAwakePatch
{
	public static EffectList HitEffect;

	public static EffectList DestroyEffect;

	private static void Postfix(ZNetScene __instance)
	{
		GameObject prefab = __instance.GetPrefab("Mistroot");
		prefab.AddComponent<HoverText>().m_text = "Mistroot";
		if (prefab.GetComponent<AzuMist>() == null)
		{
			MistrootTamerPlugin.UpdateAzuMistValues(prefab.AddComponent<AzuMist>());
		}
		HitEffect = __instance.GetPrefab("Pickable_Flax_Wild").GetComponent<Destructible>().m_hitEffect;
		DestroyEffect = __instance.GetPrefab("Pickable_Flax_Wild").GetComponent<Destructible>().m_destroyedEffect;
	}
}

}


// ---- MistrootTamer.dll :: MistrootTamer.AzuMist ----
namespace MistrootTamer
{
[<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(1)]
[<e422f648-68ec-4aec-9a93-338e95589b99>Nullable(0)]
public class AzuMist : MonoBehaviour, IDestructible
{
	public float m_ttBloom = MistrootTamerPlugin.AzuMistTTB.Value;

	public float MaxHealth = MistrootTamerPlugin.AzuMistHealth.Value;

	public HitData.DamageModifiers m_damages = new HitData.DamageModifiers
	{
		m_blunt = MistrootTamerPlugin.AzuMistBluntModifier.Value,
		m_slash = MistrootTamerPlugin.AzuMistSlashModifier.Value,
		m_pierce = MistrootTamerPlugin.AzuMistPierceModifier.Value,
		m_chop = MistrootTamerPlugin.AzuMistChopModifier.Value,
		m_pickaxe = MistrootTamerPlugin.AzuMistPickaxeModifier.Value,
		m_fire = MistrootTamerPlugin.AzuMistFireModifier.Value,
		m_frost = MistrootTamerPlugin.AzuMistFrostModifier.Value,
		m_lightning = MistrootTamerPlugin.AzuMistLightningModifier.Value,
		m_poison = MistrootTamerPlugin.AzuMistPoisonModifier.Value,
		m_spirit = MistrootTamerPlugin.AzuMistSpiritModifier.Value
	};

	public bool m_triggerPrivateArea = MistrootTamerPlugin.AzuMistTriggerPrivateArea.Value == MistrootTamerPlugin.Toggle.On;

	public GameObject m_spawnWhenDebloom;

	public static readonly List<ParticleMist> BloomingMists = new List<ParticleMist>();

	private ZNetView _znv;

	private List<ParticleMist> _mists;

	private static readonly int StartBloom = Animator.StringToHash("Start Bloom");

	private static readonly int StartDebloom = Animator.StringToHash("Start Debloom");

	private bool IsBlooming
	{
		get
		{
			return _znv.m_zdo.GetBool("IsBlooming_Azu");
		}
		set
		{
			_znv.m_zdo.Set("IsBlooming_Azu", value);
		}
	}

	private float BloomTime
	{
		get
		{
			return _znv.m_zdo.GetFloat("BloomTime_Azu");
		}
		set
		{
			_znv.m_zdo.Set("BloomTime_Azu", value);
		}
	}

	private float Health
	{
		get
		{
			return _znv.m_zdo.GetFloat(ZDOVars.s_health, MaxHealth);
		}
		set
		{
			_znv.m_zdo.Set(ZDOVars.s_health, value);
		}
	}

	private void Awake()
	{
		_znv = GetComponent<ZNetView>();
		_mists = GetComponentsInChildren<ParticleMist>(includeInactive: true).ToList();
		if (GetComponent<Mister>() == null)
		{
			base.gameObject.AddComponent<Mister>();
		}
		if (!_znv || _znv.GetZDO() == null || !_znv.IsValid())
		{
			return;
		}
		foreach (ParticleMist mist in _mists)
		{
			BloomingMists.Add(mist);
		}
		DoAnimation(0L, IsBlooming);
		_znv.Register<bool>("DoBloomAnimation", DoAnimation);
		_znv.Register<HitData>("Damage", OnDamage);
		MistrootTamerPlugin.instance.UpdateMistrootComponents();
	}

	private void DoAnimation(long sender, bool isBloom)
	{
		GetComponent<Animator>().SetTrigger((!isBloom) ? StartBloom : StartDebloom);
	}

	private void FixedUpdate()
	{
		if (_znv.IsValid() && _znv.IsOwner() && IsBlooming)
		{
			BloomTime += Time.fixedDeltaTime;
			if (!(BloomTime < m_ttBloom))
			{
				BloomTime = 0f;
				IsBlooming = false;
				Health = MaxHealth;
				_znv.InvokeRPC(ZNetView.Everybody, "DoBloomAnimation", IsBlooming);
			}
		}
	}

	private void OnDamage(long sender, HitData hit)
	{
		if (!_znv.IsOwner())
		{
			return;
		}
		ZNetSceneAwakePatch.HitEffect.Create(base.transform.position, Quaternion.identity);
		if (IsBlooming)
		{
			return;
		}
		hit.ApplyResistance(m_damages, out var significantModifier);
		float totalDamage = hit.GetTotalDamage();
		Health -= totalDamage;
		DamageText.instance.ShowText(significantModifier, hit.m_point, totalDamage);
		if (m_triggerPrivateArea)
		{
			Character attacker = hit.GetAttacker();
			if ((bool)attacker)
			{
				bool destroyed = (double)Health <= 0.0;
				PrivateArea.OnObjectDamaged(base.transform.position, attacker, destroyed);
			}
		}
		if (Health > 0f)
		{
			return;
		}
		IsBlooming = true;
		_znv.InvokeRPC(ZNetView.Everybody, "DoBloomAnimation", IsBlooming);
		ZNetSceneAwakePatch.DestroyEffect.Create(base.transform.position, Quaternion.identity);
		if ((bool)m_spawnWhenDebloom)
		{
			GameObject obj = Object.Instantiate(m_spawnWhenDebloom, base.transform.position, base.transform.rotation);
			obj.GetComponent<ZNetView>().SetLocalScale(base.transform.localScale);
			Gibber component = obj.GetComponent<Gibber>();
			if ((bool)component)
			{
				component.Setup(hit.m_point, hit.m_dir);
			}
		}
	}

	public void Damage(HitData hit)
	{
		if (_znv.IsValid() && !IsBlooming)
		{
			_znv.InvokeRPC("Damage", hit);
		}
	}

	public DestructibleType GetDestructibleType()
	{
		return DestructibleType.Everything;
	}

	private void OnDestroy()
	{
		foreach (ParticleMist mist in _mists)
		{
			BloomingMists.Remove(mist);
		}
	}
}

}


// ---- MistrootTamer.dll :: MistrootTamer.MistrootTamerPlugin ----
namespace MistrootTamer
{
[<e422f648-68ec-4aec-9a93-338e95589b99>Nullable(0)]
[<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(1)]
[BepInPlugin("WackyMole.MistrootTamer", "MistrootTamer", "1.0.7")]
public class MistrootTamerPlugin : BaseUnityPlugin
{
	[<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(0)]
	public enum Toggle
	{
		On = 1,
		Off = 0
	}

	[<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(0)]
	private class ConfigurationManagerAttributes
	{
		[UsedImplicitly]
		public int? Order;

		[UsedImplicitly]
		public bool? Browsable;

		[UsedImplicitly]
		[<e422f648-68ec-4aec-9a93-338e95589b99>Nullable(2)]
		public string Category;

		[<e422f648-68ec-4aec-9a93-338e95589b99>Nullable(new byte[] { 2, 1 })]
		[UsedImplicitly]
		public Action<ConfigEntryBase> CustomDrawer;
	}

	internal const string ModName = "MistrootTamer";

	internal const string ModVersion = "1.0.7";

	internal const string Author = "WackyMole";

	private const string ModGUID = "WackyMole.MistrootTamer";

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

	private static string ConfigFileFullPath;

	internal static string ConnectionError;

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

	public static readonly ManualLogSource MistrootTamerLogger;

	private static readonly ConfigSync ConfigSync;

	public static MistrootTamerPlugin instance;

	private static ConfigEntry<Toggle> _serverConfigLocked;

	internal static ConfigEntry<Heightmap.Biome> Biome;

	private static ConfigEntry<float> LocalRange;

	private static ConfigEntry<int> LocalEmissionRate;

	private static ConfigEntry<int> LocalEmissionPerUnit;

	private static ConfigEntry<float> MaxMistAltitude;

	private static ConfigEntry<float> DistantMaxRange;

	private static ConfigEntry<float> DistantMinSize;

	private static ConfigEntry<float> DistantMaxSize;

	private static ConfigEntry<float> DistantEmissionMax;

	private static ConfigEntry<float> DistantEmissionMaxVelocity;

	private static ConfigEntry<float> DistantThickness;

	private static ConfigEntry<float> MinDistance;

	private static ConfigEntry<float> MaxDistance;

	private static ConfigEntry<float> EmissionMax;

	private static ConfigEntry<float> EmissionPerUnit;

	private static ConfigEntry<float> MinSize;

	private static ConfigEntry<float> MaxSize;

	public static ConfigEntry<float> AzuMistHealth;

	public static ConfigEntry<float> AzuMistTTB;

	public static ConfigEntry<HitData.DamageModifier> AzuMistBluntModifier;

	public static ConfigEntry<HitData.DamageModifier> AzuMistSlashModifier;

	public static ConfigEntry<HitData.DamageModifier> AzuMistPierceModifier;

	public static ConfigEntry<HitData.DamageModifier> AzuMistChopModifier;

	public static ConfigEntry<HitData.DamageModifier> AzuMistPickaxeModifier;

	public static ConfigEntry<HitData.DamageModifier> AzuMistFireModifier;

	public static ConfigEntry<HitData.DamageModifier> AzuMistFrostModifier;

	public static ConfigEntry<HitData.DamageModifier> AzuMistLightningModifier;

	public static ConfigEntry<HitData.DamageModifier> AzuMistSpiritModifier;

	public static ConfigEntry<HitData.DamageModifier> AzuMistPoisonModifier;

	public static ConfigEntry<Toggle> AzuMistTriggerPrivateArea;

	public static ConfigEntry<string> AzuMistSpawnWhenDestroyed;

	public void Awake()
	{
		instance = this;
		bool saveOnConfigSet = base.Config.SaveOnConfigSet;
		base.Config.SaveOnConfigSet = false;
		_serverConfigLocked = config("1 - General", "Lock Configuration", Toggle.On, "If on, the configuration is locked and can be changed by server admins only.");
		ConfigSync.AddLockingConfigEntry(_serverConfigLocked);
		Biome = config("1 - General", "Biome", Heightmap.Biome.Mistlands, "Defines the biome where the mist effect is active.");
		LocalRange = config("1 - General", "Local Range", 30f, "Sets the radius around the player within which mist particles are generated.");
		LocalEmissionRate = config("1 - General", "Local Emission Rate", 50, "Controls the base rate of mist particle generation around the player.");
		LocalEmissionPerUnit = config("1 - General", "Local Emission Per Unit", 30, "Determines the number of mist particles generated per unit of movement or time.");
		MaxMistAltitude = config("1 - General", "Max Mist Altitude", 10f, "Specifies the maximum height above the ground at which mist can appear.");
		DistantMaxRange = config("2 - Misters", "Distant Max Range", 25f, "Defines the maximum distance from the player where mist can form.");
		DistantMinSize = config("2 - Misters", "Distant Min Size", 15f, "Sets the minimum size of distant mist particles.");
		DistantMaxSize = config("2 - Misters", "Distant Max Size", 20f, "Sets the maximum size of distant mist particles.");
		DistantEmissionMax = config("2 - Misters", "Distant Emission Max", 0.008f, "Controls the maximum emission rate for distant mist.");
		DistantEmissionMaxVelocity = config("2 - Misters", "Distant Emission Max Velocity", 2f, "Determines the maximum velocity at which distant mist particles move.");
		DistantThickness = config("2 - Misters", "Distant Thickness", 4f, "Specifies the thickness of the mist layer at a distance.");
		MinDistance = config("3 - Demisters", "Min Distance", 5f, "Defines the minimum distance from a source where mist begins to dissipate.");
		MaxDistance = config("3 - Demisters", "Max Distance", 40f, "Defines the maximum distance from a source at which mist is fully dissipated.");
		EmissionMax = config("3 - Demisters", "Emission Max", 0.05f, "Sets the maximum rate of mist dissipation.");
		EmissionPerUnit = config("3 - Demisters", "Emission Per Unit", 20f, "Determines the rate of mist dissipation per unit of movement or time.");
		MinSize = config("3 - Demisters", "Min Size", 5f, "Sets the minimum size of mist particles near demisters.");
		MaxSize = config("3 - Demisters", "Max Size", 15f, "Sets the maximum size of mist particles near demisters.");
		AzuMistHealth = config("4 - Mistroot", "Mistroot Health", 100f, "Sets the health of the plant.");
		AzuMistTTB = config("4 - Mistroot", "Mistroot Time To Bloom", 600f, "Sets the time to bloom of the plant. Default 10 minutes");
		AzuMistBluntModifier = config("4 - Mistroot", "Mistroot Blunt Modifier", HitData.DamageModifier.Normal, "Sets the blunt damage modifier of the plant.");
		AzuMistSlashModifier = config("4 - Mistroot", "Mistroot Slash Modifier", HitData.DamageModifier.Normal, "Sets the slash damage modifier of the plant.");
		AzuMistPierceModifier = config("4 - Mistroot", "Mistroot Pierce Modifier", HitData.DamageModifier.Normal, "Sets the pierce damage modifier of the plant.");
		AzuMistChopModifier = config("4 - Mistroot", "Mistroot Chop Modifier", HitData.DamageModifier.Normal, "Sets the chop damage modifier of the plant.");
		AzuMistPickaxeModifier = config("4 - Mistroot", "Mistroot Pickaxe Modifier", HitData.DamageModifier.Normal, "Sets the pickaxe damage modifier of the plant.");
		AzuMistFireModifier = config("4 - Mistroot", "Mistroot Fire Modifier", HitData.DamageModifier.Normal, "Sets the fire damage modifier of the plant.");
		AzuMistFrostModifier = config("4 - Mistroot", "Mistroot Frost Modifier", HitData.DamageModifier.Normal, "Sets the frost damage modifier of the plant.");
		AzuMistLightningModifier = config("4 - Mistroot", "Mistroot Lightning Modifier", HitData.DamageModifier.Normal, "Sets the lightning damage modifier of the plant.");
		AzuMistSpiritModifier = config("4 - Mistroot", "Mistroot Spirit Modifier", HitData.DamageModifier.Normal, "Sets the spirit damage modifier of the plant.");
		AzuMistPoisonModifier = config("4 - Mistroot", "Mistroot Poison Modifier", HitData.DamageModifier.Normal, "Sets the poison damage modifier of the plant.");
		AzuMistTriggerPrivateArea = config("4 - Mistroot", "Mistroot Trigger Private Area", Toggle.Off, "Sets whether the plant triggers the private area (vanilla wards) when destroyed.");
		AzuMistSpawnWhenDestroyed = config("4 - Mistroot", "Mistroot Spawn When Destroyed", "", "Sets the prefab to spawn when plant is de-bloomed. Limited to one prefab. Uses prefab name.");
		GameObject gameObject = PiecePrefabManager.RegisterPrefab("mistroottamer", "Mistroot");
		ParticleMist component = Utils.FindChild(gameObject.transform, "ThickMist_").GetComponent<ParticleMist>();
		MaterialReplacer.RegisterGameObjectForMatSwap(Utils.FindChild(gameObject.transform, "FollowPlayer").gameObject);
		MaterialReplacer.RegisterGameObjectForMatSwap(Utils.FindChild(gameObject.transform, "ThickMist_").gameObject);
		MaterialReplacer.RegisterGameObjectForMatSwap(Utils.FindChild(gameObject.transform, "LocalMist").gameObject);
		AzuMist component2 = gameObject.GetComponent<AzuMist>();
		UpdateMistValues(component);
		if (component2 != null)
		{
			UpdateAzuMistValues(component2);
		}
		else
		{
			component2 = gameObject.AddComponent<AzuMist>();
			UpdateAzuMistValues(component2);
		}
		Biome.SettingChanged += [<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(0)] (object sender, EventArgs args) =>
		{
			UpdateMistrootComponents();
		};
		LocalRange.SettingChanged += [<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(0)] (object sender, EventArgs args) =>
		{
			UpdateMistrootComponents();
		};
		LocalEmissionRate.SettingChanged += [<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(0)] (object sender, EventArgs args) =>
		{
			UpdateMistrootComponents();
		};
		LocalEmissionPerUnit.SettingChanged += [<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(0)] (object sender, EventArgs args) =>
		{
			UpdateMistrootComponents();
		};
		MaxMistAltitude.SettingChanged += [<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(0)] (object sender, EventArgs args) =>
		{
			UpdateMistrootComponents();
		};
		DistantMaxRange.SettingChanged += [<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(0)] (object sender, EventArgs args) =>
		{
			UpdateMistrootComponents();
		};
		DistantMinSize.SettingChanged += [<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(0)] (object sender, EventArgs args) =>
		{
			UpdateMistrootComponents();
		};
		DistantMaxSize.SettingChanged += [<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(0)] (object sender, EventArgs args) =>
		{
			UpdateMistrootComponents();
		};
		DistantEmissionMax.SettingChanged += [<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(0)] (object sender, EventArgs args) =>
		{
			UpdateMistrootComponents();
		};
		DistantEmissionMaxVelocity.SettingChanged += [<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(0)] (object sender, EventArgs args) =>
		{
			UpdateMistrootComponents();
		};
		DistantThickness.SettingChanged += [<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(0)] (object sender, EventArgs args) =>
		{
			UpdateMistrootComponents();
		};
		MinDistance.SettingChanged += [<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(0)] (object sender, EventArgs args) =>
		{
			UpdateMistrootComponents();
		};
		MaxDistance.SettingChanged += [<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(0)] (object sender, EventArgs args) =>
		{
			UpdateMistrootComponents();
		};
		EmissionMax.SettingChanged += [<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(0)] (object sender, EventArgs args) =>
		{
			UpdateMistrootComponents();
		};
		EmissionPerUnit.SettingChanged += [<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(0)] (object sender, EventArgs args) =>
		{
			UpdateMistrootComponents();
		};
		MinSize.SettingChanged += [<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(0)] (object sender, EventArgs args) =>
		{
			UpdateMistrootComponents();
		};
		MaxSize.SettingChanged += [<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(0)] (object sender, EventArgs args) =>
		{
			UpdateMistrootComponents();
		};
		AzuMistHealth.SettingChanged += [<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(0)] (object sender, EventArgs args) =>
		{
			UpdateMistrootComponents();
		};
		AzuMistTTB.SettingChanged += [<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(0)] (object sender, EventArgs args) =>
		{
			UpdateMistrootComponents();
		};
		AzuMistBluntModifier.SettingChanged += [<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(0)] (object sender, EventArgs args) =>
		{
			UpdateMistrootComponents();
		};
		AzuMistSlashModifier.SettingChanged += [<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(0)] (object sender, EventArgs args) =>
		{
			UpdateMistrootComponents();
		};
		AzuMistPierceModifier.SettingChanged += [<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(0)] (object sender, EventArgs args) =>
		{
			UpdateMistrootComponents();
		};
		AzuMistChopModifier.SettingChanged += [<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(0)] (object sender, EventArgs args) =>
		{
			UpdateMistrootComponents();
		};
		AzuMistPickaxeModifier.SettingChanged += [<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(0)] (object sender, EventArgs args) =>
		{
			UpdateMistrootComponents();
		};
		AzuMistFireModifier.SettingChanged += [<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(0)] (object sender, EventArgs args) =>
		{
			UpdateMistrootComponents();
		};
		AzuMistFrostModifier.SettingChanged += [<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(0)] (object sender, EventArgs args) =>
		{
			UpdateMistrootComponents();
		};
		AzuMistLightningModifier.SettingChanged += [<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(0)] (object sender, EventArgs args) =>
		{
			UpdateMistrootComponents();
		};
		AzuMistSpiritModifier.SettingChanged += [<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(0)] (object sender, EventArgs args) =>
		{
			UpdateMistrootComponents();
		};
		AzuMistPoisonModifier.SettingChanged += [<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(0)] (object sender, EventArgs args) =>
		{
			UpdateMistrootComponents();
		};
		AzuMistTriggerPrivateArea.SettingChanged += [<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(0)] (object sender, EventArgs args) =>
		{
			UpdateMistrootComponents();
		};
		AzuMistSpawnWhenDestroyed.SettingChanged += [<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(0)] (object sender, EventArgs args) =>
		{
			UpdateMistrootComponents();
		};
		Assembly executingAssembly = Assembly.GetExecutingAssembly();
		_harmony.PatchAll(executingAssembly);
		SetupWatcher();
		if (saveOnConfigSet)
		{
			base.Config.SaveOnConfigSet = saveOnConfigSet;
			base.Config.Save();
		}
	}

	internal void UpdateMistrootComponents()
	{
		foreach (ParticleMist bloomingMist in AzuMist.BloomingMists)
		{
			UpdateMistValues(bloomingMist);
		}
		if (!(ZNetScene.instance == null))
		{
			GameObject prefab = ZNetScene.instance.GetPrefab("Mistroot");
			if (!(prefab == null))
			{
				AzuMist component = prefab.GetComponent<AzuMist>();
				ParticleMist component2 = Utils.FindChild(prefab.transform, "ThickMist_").GetComponent<ParticleMist>();
				UpdateMistValues(component2);
				UpdateAzuMistValues(component);
			}
		}
	}

	internal void UpdateMistValues(ParticleMist mist)
	{
		mist.m_biome = Biome.Value;
		mist.m_localRange = LocalRange.Value;
		mist.m_localEmission = LocalEmissionRate.Value;
		mist.m_localEmissionPerUnit = LocalEmissionPerUnit.Value;
		mist.m_maxMistAltitude = MaxMistAltitude.Value;
		mist.m_distantMaxRange = DistantMaxRange.Value;
		mist.m_distantMinSize = DistantMinSize.Value;
		mist.m_distantMaxSize = DistantMaxSize.Value;
		mist.m_distantEmissionMax = DistantEmissionMax.Value;
		mist.m_distantEmissionMaxVel = DistantEmissionMaxVelocity.Value;
		mist.m_distantThickness = DistantThickness.Value;
		mist.m_minDistance = MinDistance.Value;
		mist.m_maxDistance = MaxDistance.Value;
		mist.m_emissionMax = EmissionMax.Value;
		mist.m_emissionPerUnit = EmissionPerUnit.Value;
		mist.m_minSize = MinSize.Value;
		mist.m_maxSize = MaxSize.Value;
	}

	internal static void UpdateAzuMistValues(AzuMist d)
	{
		d.MaxHealth = AzuMistHealth.Value;
		d.m_ttBloom = AzuMistTTB.Value;
		d.m_damages.m_blunt = AzuMistBluntModifier.Value;
		d.m_damages.m_slash = AzuMistSlashModifier.Value;
		d.m_damages.m_pierce = AzuMistPierceModifier.Value;
		d.m_damages.m_chop = AzuMistChopModifier.Value;
		d.m_damages.m_pickaxe = AzuMistPickaxeModifier.Value;
		d.m_damages.m_fire = AzuMistFireModifier.Value;
		d.m_damages.m_frost = AzuMistFrostModifier.Value;
		d.m_damages.m_lightning = AzuMistLightningModifier.Value;
		d.m_damages.m_spirit = AzuMistSpiritModifier.Value;
		d.m_damages.m_poison = AzuMistPoisonModifier.Value;
		d.m_triggerPrivateArea = AzuMistTriggerPrivateArea.Value == Toggle.On;
		if (ZNetScene.instance != null && !string.IsNullOrWhiteSpace(AzuMistSpawnWhenDestroyed.Value))
		{
			GameObject prefab = ZNetScene.instance.GetPrefab(AzuMistSpawnWhenDestroyed.Value);
			if (prefab != null)
			{
				d.m_spawnWhenDebloom = prefab;
			}
			else
			{
				MistrootTamerLogger.LogWarning("Prefab " + AzuMistSpawnWhenDestroyed.Value + " not found in ZNetScene.");
			}
		}
	}

	private void OnDestroy()
	{
		base.Config.Save();
	}

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

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

	private ConfigEntry<T> config<[<e422f648-68ec-4aec-9a93-338e95589b99>Nullable(2)] T>(string group, string name, T value, ConfigDescription description, bool synchronizedSetting = true)
	{
		ConfigDescription configDescription = new ConfigDescription(description.Description + (synchronizedSetting ? " [Synced with Server]" : " [Not Synced with Server]"), description.AcceptableValues, description.Tags);
		ConfigEntry<T> configEntry = base.Config.Bind(group, name, value, configDescription);
		ConfigSync.AddConfigEntry(configEntry).SynchronizedConfig = synchronizedSetting;
		return configEntry;
	}

	private ConfigEntry<T> config<[<e422f648-68ec-4aec-9a93-338e95589b99>Nullable(2)] T>(string group, string name, T value, string description, bool synchronizedSetting = true)
	{
		return config(group, name, value, new ConfigDescription(description, null), synchronizedSetting);
	}

	static MistrootTamerPlugin()
	{
		string configPath = Paths.ConfigPath;
		char directorySeparatorChar = Path.DirectorySeparatorChar;
		ConfigFileFullPath = configPath + directorySeparatorChar + ConfigFileName;
		ConnectionError = "";
		MistrootTamerLogger = BepInEx.Logging.Logger.CreateLogSource("MistrootTamer");
		ConfigSync = new ConfigSync("WackyMole.MistrootTamer")
		{
			DisplayName = "MistrootTamer",
			CurrentVersion = "1.0.7",
			MinimumRequiredVersion = "1.0.7"
		};
		instance = null;
		_serverConfigLocked = null;
		Biome = null;
		LocalRange = null;
		LocalEmissionRate = null;
		LocalEmissionPerUnit = null;
		MaxMistAltitude = null;
		DistantMaxRange = null;
		DistantMinSize = null;
		DistantMaxSize = null;
		DistantEmissionMax = null;
		DistantEmissionMaxVelocity = null;
		DistantThickness = null;
		MinDistance = null;
		MaxDistance = null;
		EmissionMax = null;
		EmissionPerUnit = null;
		MinSize = null;
		MaxSize = null;
		AzuMistHealth = null;
		AzuMistTTB = null;
		AzuMistBluntModifier = null;
		AzuMistSlashModifier = null;
		AzuMistPierceModifier = null;
		AzuMistChopModifier = null;
		AzuMistPickaxeModifier = null;
		AzuMistFireModifier = null;
		AzuMistFrostModifier = null;
		AzuMistLightningModifier = null;
		AzuMistSpiritModifier = null;
		AzuMistPoisonModifier = null;
		AzuMistTriggerPrivateArea = null;
		AzuMistSpawnWhenDestroyed = null;
	}
}

}


// ---- MistrootTamer.dll :: MistrootTamer.RegisterAndCheckVersion ----
namespace MistrootTamer
{
[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
public static class RegisterAndCheckVersion
{
	[<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(1)]
	private static void Prefix(ZNetPeer peer, ref ZNet __instance)
	{
		MistrootTamerPlugin.MistrootTamerLogger.LogDebug("Registering version RPC handler");
		peer.m_rpc.Register<ZPackage>("MistrootTamer_VersionCheck", RpcHandlers.RPC_MistrootTamer_Version);
		MistrootTamerPlugin.MistrootTamerLogger.LogDebug("Invoking version check");
		ZPackage zPackage = new ZPackage();
		zPackage.Write("1.0.7");
		peer.m_rpc.Invoke("MistrootTamer_VersionCheck", zPackage);
	}
}

}


// ---- MistrootTamer.dll :: MistrootTamer.VerifyClient ----
namespace MistrootTamer
{
[<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(1)]
[<e422f648-68ec-4aec-9a93-338e95589b99>Nullable(0)]
[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
public static class VerifyClient
{
	private static bool Prefix(ZRpc rpc, ZPackage pkg, ref ZNet __instance)
	{
		if (!__instance.IsServer() || RpcHandlers.ValidatedPeers.Contains(rpc))
		{
			return true;
		}
		MistrootTamerPlugin.MistrootTamerLogger.LogWarning("Peer (" + rpc.m_socket.GetHostName() + ") never sent version or couldn't due to previous disconnect, disconnecting");
		rpc.Invoke("Error", 3);
		return false;
	}

	private static void Postfix(ZNet __instance)
	{
		ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "MistrootTamerRequestAdminSync", new ZPackage());
	}
}

}


// ---- MistrootTamer.dll :: MistrootTamer.ShowConnectionError ----
namespace MistrootTamer
{
[HarmonyPatch(typeof(FejdStartup), "ShowConnectError")]
public class ShowConnectionError
{
	[<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(1)]
	private static void Postfix(FejdStartup __instance)
	{
		if (__instance.m_connectionFailedPanel.activeSelf)
		{
			__instance.m_connectionFailedError.fontSizeMax = 25f;
			__instance.m_connectionFailedError.fontSizeMin = 15f;
			TMP_Text connectionFailedError = __instance.m_connectionFailedError;
			connectionFailedError.text = connectionFailedError.text + "\n" + MistrootTamerPlugin.ConnectionError;
		}
	}
}

}


// ---- MistrootTamer.dll :: MistrootTamer.RemoveDisconnectedPeerFromVerified ----
namespace MistrootTamer
{
[HarmonyPatch(typeof(ZNet), "Disconnect")]
public static class RemoveDisconnectedPeerFromVerified
{
	[<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(1)]
	private static void Prefix(ZNetPeer peer, ref ZNet __instance)
	{
		if (__instance.IsServer())
		{
			MistrootTamerPlugin.MistrootTamerLogger.LogInfo("Peer (" + peer.m_rpc.m_socket.GetHostName() + ") disconnected, removing from validated list");
			RpcHandlers.ValidatedPeers.Remove(peer.m_rpc);
		}
	}
}

}


// ---- MistrootTamer.dll :: MistrootTamer.RpcHandlers ----
namespace MistrootTamer
{
[<e422f648-68ec-4aec-9a93-338e95589b99>Nullable(0)]
[<8aa9bbaf-63e8-493a-9beb-c02736005b1d>NullableContext(1)]
public static class RpcHandlers
{
	public static readonly List<ZRpc> ValidatedPeers = new List<ZRpc>();

	public static void RPC_MistrootTamer_Version(ZRpc rpc, ZPackage pkg)
	{
		string text = pkg.ReadString();
		MistrootTamerPlugin.MistrootTamerLogger.LogInfo("Version check, local: 1.0.7,  remote: " + text);
		if (text != "1.0.7")
		{
			MistrootTamerPlugin.ConnectionError = "MistrootTamer Installed: 1.0.7\n Needed: " + text;
			if (ZNet.instance.IsServer())
			{
				MistrootTamerPlugin.MistrootTamerLogger.LogWarning("Peer (" + rpc.m_socket.GetHostName() + ") has incompatible version, disconnecting...");
				rpc.Invoke("Error", 3);
			}
		}
		else if (!ZNet.instance.IsServer())
		{
			MistrootTamerPlugin.MistrootTamerLogger.LogInfo("Received same version from server!");
		}
		else
		{
			MistrootTamerPlugin.MistrootTamerLogger.LogInfo("Adding peer (" + rpc.m_socket.GetHostName() + ") to validated list");
			ValidatedPeers.Add(rpc);
		}
	}
}

}


// ---- MistrootTamer.dll :: ServerSync.OwnConfigEntryBase ----
namespace ServerSync
{
[PublicAPI]
[<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(0)]
[<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(1)]
internal abstract class OwnConfigEntryBase
{
	[<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(2)]
	public object LocalBaseValue;

	public bool SynchronizedConfig = true;

	public abstract ConfigEntryBase BaseConfig { get; }
}

}


// ---- MistrootTamer.dll :: ServerSync.SyncedConfigEntry`1 ----
namespace ServerSync
{
[PublicAPI]
[<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(1)]
[<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(0)]
internal class SyncedConfigEntry<[<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(2)] T>(ConfigEntry<T> sourceConfig) : OwnConfigEntryBase
{
	public readonly ConfigEntry<T> SourceConfig = sourceConfig;

	public override ConfigEntryBase BaseConfig => SourceConfig;

	public T Value
	{
		get
		{
			return SourceConfig.Value;
		}
		set
		{
			SourceConfig.Value = value;
		}
	}

	public void AssignLocalValue(T value)
	{
		if (LocalBaseValue == null)
		{
			Value = value;
		}
		else
		{
			LocalBaseValue = value;
		}
	}
}

}


// ---- MistrootTamer.dll :: ServerSync.CustomSyncedValueBase ----
namespace ServerSync
{
[<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(2)]
[<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(0)]
internal abstract class CustomSyncedValueBase
{
	public object LocalBaseValue;

	[<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(1)]
	public readonly string Identifier;

	[<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(1)]
	public readonly Type Type;

	private object boxedValue;

	protected bool localIsOwner;

	public readonly int Priority;

	public object BoxedValue
	{
		get
		{
			return boxedValue;
		}
		set
		{
			boxedValue = value;
			this.ValueChanged?.Invoke();
		}
	}

	public event Action ValueChanged;

	[<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(1)]
	protected CustomSyncedValueBase(ConfigSync configSync, string identifier, Type type, int priority)
	{
		Priority = priority;
		Identifier = identifier;
		Type = type;
		configSync.AddCustomValue(this);
		localIsOwner = configSync.IsSourceOfTruth;
		configSync.SourceOfTruthChanged += delegate(bool truth)
		{
			localIsOwner = truth;
		};
	}
}

}


// ---- MistrootTamer.dll :: ServerSync.CustomSyncedValue`1 ----
namespace ServerSync
{
[PublicAPI]
[<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(0)]
[<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(1)]
internal sealed class CustomSyncedValue<[<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(2)] T> : CustomSyncedValueBase
{
	public T Value
	{
		get
		{
			return (T)base.BoxedValue;
		}
		set
		{
			base.BoxedValue = value;
		}
	}

	public CustomSyncedValue(ConfigSync configSync, string identifier, T value = default(T), int priority = 0)
		: base(configSync, identifier, typeof(T), priority)
	{
		Value = value;
	}

	public void AssignLocalValue(T value)
	{
		if (localIsOwner)
		{
			Value = value;
		}
		else
		{
			LocalBaseValue = value;
		}
	}
}

}


// ---- MistrootTamer.dll :: ServerSync.ConfigurationManagerAttributes ----
namespace ServerSync
{
internal class ConfigurationManagerAttributes
{
	[UsedImplicitly]
	public bool? ReadOnly = false;
}

}


// ---- MistrootTamer.dll :: ServerSync.ConfigSync ----
namespace ServerSync
{
[<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(1)]
[<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(0)]
[PublicAPI]
internal class ConfigSync
{
	[<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(0)]
	[HarmonyPatch(typeof(ZRpc), "HandlePackage")]
	private static class SnatchCurrentlyHandlingRPC
	{
		[<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(2)]
		public static ZRpc currentRpc;

		[HarmonyPrefix]
		[<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(1)]
		private static void Prefix(ZRpc __instance)
		{
			currentRpc = __instance;
		}
	}

	[<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(0)]
	[HarmonyPatch(typeof(ZNet), "Awake")]
	internal static class RegisterRPCPatch
	{
		[<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(1)]
		[HarmonyPostfix]
		private static void Postfix(ZNet __instance)
		{
			isServer = __instance.IsServer();
			foreach (ConfigSync configSync2 in configSyncs)
			{
				ZRoutedRpc.instance.Register<ZPackage>(configSync2.Name + " ConfigSync", configSync2.RPC_FromOtherClientConfigSync);
				if (isServer)
				{
					configSync2.InitialSyncDone = true;
					Debug.Log("Registered '" + configSync2.Name + " ConfigSync' RPC - waiting for incoming connections");
				}
			}
			if (isServer)
			{
				__instance.StartCoroutine(WatchAdminListChanges());
			}
			[<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(1)]
			static void SendAdmin(List<ZNetPeer> peers, bool isAdmin)
			{
				ZPackage package = ConfigsToPackage(null, null, new PackageEntry[1]
				{
					new PackageEntry
					{
						section = "Internal",
						key = "lockexempt",
						type = typeof(bool),
						value = isAdmin
					}
				});
				ConfigSync configSync = configSyncs.First();
				if (configSync != null)
				{
					ZNet.instance.StartCoroutine(configSync.sendZPackage(peers, package));
				}
			}
			[<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(1)]
			static IEnumerator WatchAdminListChanges()
			{
				MethodInfo listContainsId = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId");
				SyncedList adminList = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
				List<string> CurrentList = new List<string>(adminList.GetList());
				while (true)
				{
					yield return new WaitForSeconds(30f);
					if (!adminList.GetList().SequenceEqual(CurrentList))
					{
						CurrentList = new List<string>(adminList.GetList());
						List<ZNetPeer> adminPeer = ZNet.instance.GetPeers().Where(delegate(ZNetPeer p)
						{
							string hostName = p.m_rpc.GetSocket().GetHostName();
							return ((object)listContainsId == null) ? adminList.Contains(hostName) : ((bool)listContainsId.Invoke(ZNet.instance, new object[2] { adminList, hostName }));
						}).ToList();
						List<ZNetPeer> nonAdminPeer = ZNet.instance.GetPeers().Except(adminPeer).ToList();
						SendAdmin(nonAdminPeer, isAdmin: false);
						SendAdmin(adminPeer, isAdmin: true);
					}
				}
			}
		}
	}

	[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
	[<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(0)]
	private static class RegisterClientRPCPatch
	{
		[HarmonyPostfix]
		[<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(1)]
		private static void Postfix(ZNet __instance, ZNetPeer peer)
		{
			if (__instance.IsServer())
			{
				return;
			}
			foreach (ConfigSync configSync in configSyncs)
			{
				peer.m_rpc.Register<ZPackage>(configSync.Name + " ConfigSync", configSync.RPC_FromServerConfigSync);
			}
		}
	}

	[<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(0)]
	private class ParsedConfigs
	{
		[<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(new byte[] { 1, 1, 2 })]
		public readonly Dictionary<OwnConfigEntryBase, object> configValues = new Dictionary<OwnConfigEntryBase, object>();

		[<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(new byte[] { 1, 1, 2 })]
		public readonly Dictionary<CustomSyncedValueBase, object> customValues = new Dictionary<CustomSyncedValueBase, object>();
	}

	[HarmonyPatch(typeof(ZNet), "Shutdown")]
	[<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(0)]
	private class ResetConfigsOnShutdown
	{
		[HarmonyPostfix]
		private static void Postfix()
		{
			ProcessingServerUpdate = true;
			foreach (ConfigSync configSync in configSyncs)
			{
				configSync.resetConfigsFromServer();
				configSync.IsSourceOfTruth = true;
				configSync.InitialSyncDone = false;
			}
			ProcessingServerUpdate = false;
		}
	}

	[<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(0)]
	[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
	private class SendConfigsAfterLogin
	{
		[<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(0)]
		private class BufferingSocket(ISocket original) : ZPlayFabSocket, ISocket
		{
			public volatile bool finished = false;

			public volatile int versionMatchQueued = -1;

			public readonly List<ZPackage> Package = new List<ZPackage>();

			public readonly ISocket Original = original;

			public new bool IsConnected()
			{
				return Original.IsConnected();
			}

			public new ZPackage Recv()
			{
				return Original.Recv();
			}

			public new int GetSendQueueSize()
			{
				return Original.GetSendQueueSize();
			}

			public new int GetCurrentSendRate()
			{
				return Original.GetCurrentSendRate();
			}

			public new bool IsHost()
			{
				return Original.IsHost();
			}

			public new void Dispose()
			{
				Original.Dispose();
			}

			public new bool GotNewData()
			{
				return Original.GotNewData();
			}

			public new void Close()
			{
				Original.Close();
			}

			public new string GetEndPointString()
			{
				return Original.GetEndPointString();
			}

			public new void GetAndResetStats(out int totalSent, out int totalRecv)
			{
				Original.GetAndResetStats(out totalSent, out totalRecv);
			}

			public new void GetConnectionQuality(out float localQuality, out float remoteQuality, out int ping, out float outByteSec, out float inByteSec)
			{
				Original.GetConnectionQuality(out localQuality, out remoteQuality, out ping, out outByteSec, out inByteSec);
			}

			public new ISocket Accept()
			{
				return Original.Accept();
			}

			public new int GetHostPort()
			{
				return Original.GetHostPort();
			}

			public new bool Flush()
			{
				return Original.Flush();
			}

			public new string GetHostName()
			{
				return Original.GetHostName();
			}

			public new void VersionMatch()
			{
				if (finished)
				{
					Original.VersionMatch();
				}
				else
				{
					versionMatchQueued = Package.Count;
				}
			}

			public new void Send(ZPackage pkg)
			{
				int pos = pkg.GetPos();
				pkg.SetPos(0);
				int num = pkg.ReadInt();
				if ((num == "PeerInfo".GetStableHashCode() || num == "RoutedRPC".GetStableHashCode() || num == "ZDOData".GetStableHashCode()) && !finished)
				{
					ZPackage zPackage = new ZPackage(pkg.GetArray());
					zPackage.SetPos(pos);
					Package.Add(zPackage);
				}
				else
				{
					pkg.SetPos(pos);
					Original.Send(pkg);
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static void Prefix([<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(new byte[] { 2, 1, 1 })] ref Dictionary<Assembly, BufferingSocket> __state, ZNet __instance, ZRpc rpc)
		{
			if (!__instance.IsServer())
			{
				return;
			}
			BufferingSocket bufferingSocket = new BufferingSocket(rpc.GetSocket());
			AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc, bufferingSocket);
			if (AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }).Invoke(__instance, new object[1] { rpc }) is ZNetPeer obj && ZNet.m_onlineBackend != OnlineBackendType.Steamworks)
			{
				FieldInfo fieldInfo = AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket");
				if (fieldInfo.GetValue(obj) is ZPlayFabSocket zPlayFabSocket)
				{
					typeof(ZPlayFabSocket).GetField("m_remotePlayerId").SetValue(bufferingSocket, zPlayFabSocket.m_remotePlayerId);
				}
				fieldInfo.SetValue(obj, bufferingSocket);
			}
			if (__state == null)
			{
				__state = new Dictionary<Assembly, BufferingSocket>();
			}
			__state[Assembly.GetExecutingAssembly()] = bufferingSocket;
		}

		[HarmonyPostfix]
		private static void Postfix(Dictionary<Assembly, BufferingSocket> __state, ZNet __instance, ZRpc rpc)
		{
			ZNetPeer peer;
			if (__instance.IsServer())
			{
				object obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }).Invoke(__instance, new object[1] { rpc });
				peer = obj as ZNetPeer;
				if (peer == null)
				{
					SendBufferedData();
				}
				else
				{
					__instance.StartCoroutine(sendAsync());
				}
			}
			IEnumerator sendAsync()
			{
				foreach (ConfigSync configSync in configSyncs)
				{
					List<PackageEntry> entries = new List<PackageEntry>();
					if (configSync.CurrentVersion != null)
					{
						entries.Add(new PackageEntry
						{
							section = "Internal",
							key = "serverversion",
							type = typeof(string),
							value = configSync.CurrentVersion
						});
					}
					MethodInfo listContainsId = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId");
					SyncedList adminList = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
					entries.Add(new PackageEntry
					{
						section = "Internal",
						key = "lockexempt",
						type = typeof(bool),
						value = (((object)listContainsId == null) ? ((object)adminList.Contains(rpc.GetSocket().GetHostName())) : listContainsId.Invoke(ZNet.instance, new object[2]
						{
							adminList,
							rpc.GetSocket().GetHostName()
						}))
					});
					ZPackage package = ConfigsToPackage(configSync.allConfigs.Select([<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(0)] (OwnConfigEntryBase c) => c.BaseConfig), configSync.allCustomValues, entries, partial: false);
					yield return __instance.StartCoroutine(configSync.sendZPackage(new List<ZNetPeer> { peer }, package));
				}
				SendBufferedData();
			}
			void SendBufferedData()
			{
				if (rpc.GetSocket() is BufferingSocket bufferingSocket)
				{
					AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc, bufferingSocket.Original);
					if (AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }).Invoke(__instance, new object[1] { rpc }) is ZNetPeer obj2)
					{
						AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket").SetValue(obj2, bufferingSocket.Original);
					}
				}
				BufferingSocket bufferingSocket2 = __state[Assembly.GetExecutingAssembly()];
				bufferingSocket2.finished = true;
				for (int i = 0; i < bufferingSocket2.Package.Count; i++)
				{
					if (i == bufferingSocket2.versionMatchQueued)
					{
						bufferingSocket2.Original.VersionMatch();
					}
					bufferingSocket2.Original.Send(bufferingSocket2.Package[i]);
				}
				if (bufferingSocket2.Package.Count == bufferingSocket2.versionMatchQueued)
				{
					bufferingSocket2.Original.VersionMatch();
				}
			}
		}
	}

	[<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(0)]
	private class PackageEntry
	{
		public string section = null;

		public string key = null;

		public Type type = null;

		[<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(2)]
		public object value;
	}

	[<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(0)]
	[HarmonyPatch(typeof(ConfigEntryBase), "GetSerializedValue")]
	private static class PreventSavingServerInfo
	{
		[HarmonyPrefix]
		[<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(1)]
		private static bool Prefix(ConfigEntryBase __instance, ref string __result)
		{
			OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
			if (ownConfigEntryBase == null || isWritableConfig(ownConfigEntryBase))
			{
				return true;
			}
			__result = TomlTypeConverter.ConvertToString(ownConfigEntryBase.LocalBaseValue, __instance.SettingType);
			return false;
		}
	}

	[<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(0)]
	[HarmonyPatch(typeof(ConfigEntryBase), "SetSerializedValue")]
	private static class PreventConfigRereadChangingValues
	{
		[HarmonyPrefix]
		[<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(1)]
		private static bool Prefix(ConfigEntryBase __instance, string value)
		{
			OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
			if (ownConfigEntryBase == null || ownConfigEntryBase.LocalBaseValue == null)
			{
				return true;
			}
			try
			{
				ownConfigEntryBase.LocalBaseValue = TomlTypeConverter.ConvertToValue(value, __instance.SettingType);
			}
			catch (Exception ex)
			{
				Debug.LogWarning($"Config value of setting \"{__instance.Definition}\" could not be parsed and will be ignored. Reason: {ex.Message}; Value: {value}");
			}
			return false;
		}
	}

	[<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(0)]
	private class InvalidDeserializationTypeException : Exception
	{
		public string expected = null;

		public string received = null;

		public string field = "";
	}

	public static bool ProcessingServerUpdate;

	public readonly string Name;

	[<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(2)]
	public string DisplayName;

	[<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(2)]
	public string CurrentVersion;

	[<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(2)]
	public string MinimumRequiredVersion;

	public bool ModRequired = false;

	private bool? forceConfigLocking;

	private bool isSourceOfTruth = true;

	private static readonly HashSet<ConfigSync> configSyncs;

	private readonly HashSet<OwnConfigEntryBase> allConfigs = new HashSet<OwnConfigEntryBase>();

	private HashSet<CustomSyncedValueBase> allCustomValues = new HashSet<CustomSyncedValueBase>();

	private static bool isServer;

	private static bool lockExempt;

	[<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(2)]
	private OwnConfigEntryBase lockedConfig = null;

	private const byte PARTIAL_CONFIGS = 1;

	private const byte FRAGMENTED_CONFIG = 2;

	private const byte COMPRESSED_CONFIG = 4;

	private readonly Dictionary<string, SortedDictionary<int, byte[]>> configValueCache = new Dictionary<string, SortedDictionary<int, byte[]>>();

	[<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(new byte[] { 1, 0, 1 })]
	private readonly List<KeyValuePair<long, string>> cacheExpirations = new List<KeyValuePair<long, string>>();

	private static long packageCounter;

	public bool IsLocked
	{
		get
		{
			bool? flag = forceConfigLocking;
			bool num;
			if (!flag.HasValue)
			{
				if (lockedConfig == null)
				{
					goto IL_0052;
				}
				num = ((IConvertible)lockedConfig.BaseConfig.BoxedValue).ToInt32(CultureInfo.InvariantCulture) != 0;
			}
			else
			{
				num = flag == true;
			}
			if (!num)
			{
				goto IL_0052;
			}
			int result = ((!lockExempt) ? 1 : 0);
			goto IL_0053;
			IL_0052:
			result = 0;
			goto IL_0053;
			IL_0053:
			return (byte)result != 0;
		}
		set
		{
			forceConfigLocking = value;
		}
	}

	public bool IsAdmin => lockExempt || isSourceOfTruth;

	public bool IsSourceOfTruth
	{
		get
		{
			return isSourceOfTruth;
		}
		private set
		{
			if (value != isSourceOfTruth)
			{
				isSourceOfTruth = value;
				this.SourceOfTruthChanged?.Invoke(value);
			}
		}
	}

	public bool InitialSyncDone { get; private set; } = false;

	[<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(2)]
	[method: <80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(2)]
	[field: <c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(2)]
	public event Action<bool> SourceOfTruthChanged;

	[<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(2)]
	[method: <80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(2)]
	[field: <c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(2)]
	private event Action lockedConfigChanged;

	static ConfigSync()
	{
		ProcessingServerUpdate = false;
		configSyncs = new HashSet<ConfigSync>();
		lockExempt = false;
		packageCounter = 0L;
		RuntimeHelpers.RunClassConstructor(typeof(VersionCheck).TypeHandle);
	}

	public ConfigSync(string name)
	{
		Name = name;
		configSyncs.Add(this);
		new VersionCheck(this);
	}

	public SyncedConfigEntry<T> AddConfigEntry<[<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(2)] T>(ConfigEntry<T> configEntry)
	{
		OwnConfigEntryBase ownConfigEntryBase = configData(configEntry);
		SyncedConfigEntry<T> syncedEntry = ownConfigEntryBase as SyncedConfigEntry<T>;
		if (syncedEntry == null)
		{
			syncedEntry = new SyncedConfigEntry<T>(configEntry);
			AccessTools.DeclaredField(typeof(ConfigDescription), "<Tags>k__BackingField").SetValue(configEntry.Description, new object[1]
			{
				new ConfigurationManagerAttributes()
			}.Concat(configEntry.Description.Tags ?? Array.Empty<object>()).Concat(new SyncedConfigEntry<T>[1] { syncedEntry }).ToArray());
			configEntry.SettingChanged += [<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(0)] (object _, EventArgs _) =>
			{
				if (!ProcessingServerUpdate && syncedEntry.SynchronizedConfig)
				{
					Broadcast(ZRoutedRpc.Everybody, configEntry);
				}
			};
			allConfigs.Add(syncedEntry);
		}
		return syncedEntry;
	}

	public SyncedConfigEntry<T> AddLockingConfigEntry<[<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(0)] T>(ConfigEntry<T> lockingConfig) where T : IConvertible
	{
		if (lockedConfig != null)
		{
			throw new Exception("Cannot initialize locking ConfigEntry twice");
		}
		lockedConfig = AddConfigEntry(lockingConfig);
		lockingConfig.SettingChanged += [<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(0)] (object _, EventArgs _) =>
		{
			this.lockedConfigChanged?.Invoke();
		};
		return (SyncedConfigEntry<T>)lockedConfig;
	}

	internal void AddCustomValue(CustomSyncedValueBase customValue)
	{
		if (allCustomValues.Select([<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(0)] (CustomSyncedValueBase v) => v.Identifier).Concat(new string[1] { "serverversion" }).Contains(customValue.Identifier))
		{
			throw new Exception("Cannot have multiple settings with the same name or with a reserved name (serverversion)");
		}
		allCustomValues.Add(customValue);
		allCustomValues = new HashSet<CustomSyncedValueBase>(allCustomValues.OrderByDescending([<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(0)] (CustomSyncedValueBase v) => v.Priority));
		customValue.ValueChanged += delegate
		{
			if (!ProcessingServerUpdate)
			{
				Broadcast(ZRoutedRpc.Everybody, customValue);
			}
		};
	}

	private void RPC_FromServerConfigSync(ZRpc rpc, ZPackage package)
	{
		lockedConfigChanged += serverLockedSettingChanged;
		IsSourceOfTruth = false;
		if (HandleConfigSyncRPC(0L, package, clientUpdate: false))
		{
			InitialSyncDone = true;
		}
	}

	private void RPC_FromOtherClientConfigSync(long sender, ZPackage package)
	{
		HandleConfigSyncRPC(sender, package, clientUpdate: true);
	}

	private bool HandleConfigSyncRPC(long sender, ZPackage package, bool clientUpdate)
	{
		try
		{
			if (isServer && IsLocked)
			{
				string text = SnatchCurrentlyHandlingRPC.currentRpc?.GetSocket()?.GetHostName();
				if (text != null)
				{
					MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId");
					SyncedList syncedList = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
					if (!(((object)methodInfo == null) ? syncedList.Contains(text) : ((bool)methodInfo.Invoke(ZNet.instance, new object[2] { syncedList, text }))))
					{
						return false;
					}
				}
			}
			cacheExpirations.RemoveAll(([<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(new byte[] { 0, 1 })] KeyValuePair<long, string> kv) =>
			{
				if (kv.Key < DateTimeOffset.Now.Ticks)
				{
					configValueCache.Remove(kv.Value);
					return true;
				}
				return false;
			});
			byte b = package.ReadByte();
			if ((b & 2) != 0)
			{
				long num = package.ReadLong();
				string text2 = sender.ToString() + num;
				if (!configValueCache.TryGetValue(text2, out var value))
				{
					value = new SortedDictionary<int, byte[]>();
					configValueCache[text2] = value;
					cacheExpirations.Add(new KeyValuePair<long, string>(DateTimeOffset.Now.AddSeconds(60.0).Ticks, text2));
				}
				int key = package.ReadInt();
				int num2 = package.ReadInt();
				value.Add(key, package.ReadByteArray());
				if (value.Count < num2)
				{
					return false;
				}
				configValueCache.Remove(text2);
				package = new ZPackage(value.Values.SelectMany([<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(0)] (byte[] a) => a).ToArray());
				b = package.ReadByte();
			}
			ProcessingServerUpdate = true;
			if ((b & 4) != 0)
			{
				byte[] buffer = package.ReadByteArray();
				MemoryStream stream = new MemoryStream(buffer);
				MemoryStream memoryStream = new MemoryStream();
				using (DeflateStream deflateStream = new DeflateStream(stream, CompressionMode.Decompress))
				{
					deflateStream.CopyTo(memoryStream);
				}
				package = new ZPackage(memoryStream.ToArray());
				b = package.ReadByte();
			}
			if ((b & 1) == 0)
			{
				resetConfigsFromServer();
			}
			ParsedConfigs parsedConfigs = ReadConfigsFromPackage(package);
			ConfigFile configFile = null;
			bool saveOnConfigSet = false;
			foreach (KeyValuePair<OwnConfigEntryBase, object> configValue in parsedConfigs.configValues)
			{
				if (!isServer && configValue.Key.LocalBaseValue == null)
				{
					configValue.Key.LocalBaseValue = configValue.Key.BaseConfig.BoxedValue;
				}
				if (configFile == null)
				{
					configFile = configValue.Key.BaseConfig.ConfigFile;
					saveOnConfigSet = configFile.SaveOnConfigSet;
					configFile.SaveOnConfigSet = false;
				}
				configValue.Key.BaseConfig.BoxedValue = configValue.Value;
			}
			if (configFile != null)
			{
				configFile.SaveOnConfigSet = saveOnConfigSet;
			}
			foreach (KeyValuePair<CustomSyncedValueBase, object> customValue in parsedConfigs.customValues)
			{
				if (!isServer)
				{
					CustomSyncedValueBase key2 = customValue.Key;
					if (key2.LocalBaseValue == null)
					{
						key2.LocalBaseValue = customValue.Key.BoxedValue;
					}
				}
				customValue.Key.BoxedValue = customValue.Value;
			}
			Debug.Log(string.Format("Received {0} configs and {1} custom values from {2} for mod {3}", parsedConfigs.configValues.Count, parsedConfigs.customValues.Count, (isServer || clientUpdate) ? $"client {sender}" : "the server", DisplayName ?? Name));
			if (!isServer)
			{
				serverLockedSettingChanged();
			}
			return true;
		}
		finally
		{
			ProcessingServerUpdate = false;
		}
	}

	private ParsedConfigs ReadConfigsFromPackage(ZPackage package)
	{
		ParsedConfigs parsedConfigs = new ParsedConfigs();
		Dictionary<string, OwnConfigEntryBase> dictionary = allConfigs.Where([<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(0)] (OwnConfigEntryBase c) => c.SynchronizedConfig).ToDictionary([<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(0)] (OwnConfigEntryBase c) => c.BaseConfig.Definition.Section + "_" + c.BaseConfig.Definition.Key, [<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(0)] (OwnConfigEntryBase c) => c);
		Dictionary<string, CustomSyncedValueBase> dictionary2 = allCustomValues.ToDictionary([<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(0)] (CustomSyncedValueBase c) => c.Identifier, [<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(0)] (CustomSyncedValueBase c) => c);
		int num = package.ReadInt();
		for (int num2 = 0; num2 < num; num2++)
		{
			string text = package.ReadString();
			string text2 = package.ReadString();
			string text3 = package.ReadString();
			Type type = Type.GetType(text3);
			if (text3 == "" || type != null)
			{
				object obj;
				try
				{
					obj = ((text3 == "") ? null : ReadValueWithTypeFromZPackage(package, type));
				}
				catch (InvalidDeserializationTypeException ex)
				{
					Debug.LogWarning("Got unexpected struct internal type " + ex.received + " for field " + ex.field + " struct " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + ex.expected);
					continue;
				}
				OwnConfigEntryBase value2;
				if (text == "Internal")
				{
					CustomSyncedValueBase value;
					if (text2 == "serverversion")
					{
						if (obj?.ToString() != CurrentVersion)
						{
							Debug.LogWarning("Received server version is not equal: server version = " + (obj?.ToString() ?? "null") + "; local version = " + (CurrentVersion ?? "unknown"));
						}
					}
					else if (text2 == "lockexempt")
					{
						if (obj is bool flag)
						{
							lockExempt = flag;
						}
					}
					else if (dictionary2.TryGetValue(text2, out value))
					{
						if ((text3 == "" && (!value.Type.IsValueType || Nullable.GetUnderlyingType(value.Type) != null)) || GetZPackageTypeString(value.Type) == text3)
						{
							parsedConfigs.customValues[value] = obj;
							continue;
						}
						Debug.LogWarning("Got unexpected type " + text3 + " for internal value " + text2 + " for mod " + (DisplayName ?? Name) + ", expecting " + value.Type.AssemblyQualifiedName);
					}
				}
				else if (dictionary.TryGetValue(text + "_" + text2, out value2))
				{
					Type type2 = configType(value2.BaseConfig);
					if ((text3 == "" && (!type2.IsValueType || Nullable.GetUnderlyingType(type2) != null)) || GetZPackageTypeString(type2) == text3)
					{
						parsedConfigs.configValues[value2] = obj;
						continue;
					}
					Debug.LogWarning("Got unexpected type " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + type2.AssemblyQualifiedName);
				}
				else
				{
					Debug.LogWarning("Received unknown config entry " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ". This may happen if client and server versions of the mod do not match.");
				}
				continue;
			}
			Debug.LogWarning("Got invalid type " + text3 + ", abort reading of received configs");
			return new ParsedConfigs();
		}
		return parsedConfigs;
	}

	private static bool isWritableConfig(OwnConfigEntryBase config)
	{
		ConfigSync configSync = configSyncs.FirstOrDefault([<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(0)] (ConfigSync cs) => cs.allConfigs.Contains(config));
		if (configSync == null)
		{
			return true;
		}
		return configSync.IsSourceOfTruth || !config.SynchronizedConfig || config.LocalBaseValue == null || (!configSync.IsLocked && (config != configSync.lockedConfig || lockExempt));
	}

	private void serverLockedSettingChanged()
	{
		foreach (OwnConfigEntryBase allConfig in allConfigs)
		{
			configAttribute<ConfigurationManagerAttributes>(allConfig.BaseConfig).ReadOnly = !isWritableConfig(allConfig);
		}
	}

	private void resetConfigsFromServer()
	{
		ConfigFile configFile = null;
		bool saveOnConfigSet = false;
		foreach (OwnConfigEntryBase item in allConfigs.Where([<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(0)] (OwnConfigEntryBase config) => config.LocalBaseValue != null))
		{
			if (configFile == null)
			{
				configFile = item.BaseConfig.ConfigFile;
				saveOnConfigSet = configFile.SaveOnConfigSet;
				configFile.SaveOnConfigSet = false;
			}
			item.BaseConfig.BoxedValue = item.LocalBaseValue;
			item.LocalBaseValue = null;
		}
		if (configFile != null)
		{
			configFile.SaveOnConfigSet = saveOnConfigSet;
		}
		foreach (CustomSyncedValueBase item2 in allCustomValues.Where([<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(0)] (CustomSyncedValueBase config) => config.LocalBaseValue != null))
		{
			item2.BoxedValue = item2.LocalBaseValue;
			item2.LocalBaseValue = null;
		}
		lockedConfigChanged -= serverLockedSettingChanged;
		serverLockedSettingChanged();
	}

	private IEnumerator<bool> distributeConfigToPeers(ZNetPeer peer, ZPackage package)
	{
		ZRoutedRpc rpc = ZRoutedRpc.instance;
		if (rpc == null)
		{
			yield break;
		}
		byte[] data = package.GetArray();
		if (data != null && data.LongLength > 250000)
		{
			int fragments = (int)(1 + (data.LongLength - 1) / 250000);
			long packageIdentifier = ++packageCounter;
			int fragment = 0;
			while (fragment < fragments)
			{
				foreach (bool item in waitForQueue())
				{
					yield return item;
				}
				if (peer.m_socket.IsConnected())
				{
					ZPackage fragmentedPackage = new ZPackage();
					fragmentedPackage.Write((byte)2);
					fragmentedPackage.Write(packageIdentifier);
					fragmentedPackage.Write(fragment);
					fragmentedPackage.Write(fragments);
					fragmentedPackage.Write(data.Skip(250000 * fragment).Take(250000).ToArray());
					SendPackage(fragmentedPackage);
					if (fragment != fragments - 1)
					{
						yield return true;
					}
					int num = fragment + 1;
					fragment = num;
					continue;
				}
				break;
			}
			yield break;
		}
		foreach (bool item2 in waitForQueue())
		{
			yield return item2;
		}
		SendPackage(package);
		void SendPackage(ZPackage pkg)
		{
			string text = Name + " ConfigSync";
			if (isServer)
			{
				peer.m_rpc.Invoke(text, pkg);
			}
			else
			{
				rpc.InvokeRoutedRPC(peer.m_server ? 0 : peer.m_uid, text, pkg);
			}
		}
		IEnumerable<bool> waitForQueue()
		{
			float timeout = Time.time + 30f;
			while (peer.m_socket.GetSendQueueSize() > 20000)
			{
				if (Time.time > timeout)
				{
					Debug.Log($"Disconnecting {peer.m_uid} after 30 seconds config sending timeout");
					peer.m_rpc.Invoke("Error", ZNet.ConnectionStatus.ErrorConnectFailed);
					ZNet.instance.Disconnect(peer);
					break;
				}
				yield return false;
			}
		}
	}

	private IEnumerator sendZPackage(long target, ZPackage package)
	{
		if (!ZNet.instance)
		{
			return Enumerable.Empty<object>().GetEnumerator();
		}
		List<ZNetPeer> list = (List<ZNetPeer>)AccessTools.DeclaredField(typeof(ZRoutedRpc), "m_peers").GetValue(ZRoutedRpc.instance);
		if (target != ZRoutedRpc.Everybody)
		{
			list = list.Where([<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(0)] (ZNetPeer p) => p.m_uid == target).ToList();
		}
		return sendZPackage(list, package);
	}

	private IEnumerator sendZPackage(List<ZNetPeer> peers, ZPackage package)
	{
		if (!ZNet.instance)
		{
			yield break;
		}
		byte[] rawData = package.GetArray();
		if (rawData != null && rawData.LongLength > 10000)
		{
			ZPackage compressedPackage = new ZPackage();
			compressedPackage.Write((byte)4);
			MemoryStream output = new MemoryStream();
			using (DeflateStream deflateStream = new DeflateStream(output, System.IO.Compression.CompressionLevel.Optimal))
			{
				deflateStream.Write(rawData, 0, rawData.Length);
			}
			compressedPackage.Write(output.ToArray());
			package = compressedPackage;
		}
		List<IEnumerator<bool>> writers = (from p in peers
			where p.IsReady()
			select distributeConfigToPeers(p, package)).ToList();
		writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
		while (writers.Count > 0)
		{
			yield return null;
			writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
		}
	}

	private void Broadcast(long target, params ConfigEntryBase[] configs)
	{
		if (!IsLocked || isServer)
		{
			ZPackage package = ConfigsToPackage(configs);
			ZNet.instance?.StartCoroutine(sendZPackage(target, package));
		}
	}

	private void Broadcast(long target, params CustomSyncedValueBase[] customValues)
	{
		if (!IsLocked || isServer)
		{
			ZPackage package = ConfigsToPackage(null, customValues);
			ZNet.instance?.StartCoroutine(sendZPackage(target, package));
		}
	}

	[return: <c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(2)]
	private static OwnConfigEntryBase configData(ConfigEntryBase config)
	{
		return config.Description.Tags?.OfType<OwnConfigEntryBase>().SingleOrDefault();
	}

	[return: <c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(new byte[] { 2, 1 })]
	public static SyncedConfigEntry<T> ConfigData<[<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(2)] T>(ConfigEntry<T> config)
	{
		return config.Description.Tags?.OfType<SyncedConfigEntry<T>>().SingleOrDefault();
	}

	private static T configAttribute<[<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(2)] T>(ConfigEntryBase config)
	{
		return config.Description.Tags.OfType<T>().First();
	}

	private static Type configType(ConfigEntryBase config)
	{
		return configType(config.SettingType);
	}

	private static Type configType(Type type)
	{
		return type.IsEnum ? Enum.GetUnderlyingType(type) : type;
	}

	private static ZPackage ConfigsToPackage([<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(new byte[] { 2, 1 })] IEnumerable<ConfigEntryBase> configs = null, [<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(new byte[] { 2, 1 })] IEnumerable<CustomSyncedValueBase> customValues = null, [<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(new byte[] { 2, 1 })] IEnumerable<PackageEntry> packageEntries = null, bool partial = true)
	{
		List<ConfigEntryBase> list = configs?.Where([<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(0)] (ConfigEntryBase config) => configData(config).SynchronizedConfig).ToList() ?? new List<ConfigEntryBase>();
		List<CustomSyncedValueBase> list2 = customValues?.ToList() ?? new List<CustomSyncedValueBase>();
		ZPackage zPackage = new ZPackage();
		zPackage.Write((byte)(partial ? 1 : 0));
		zPackage.Write(list.Count + list2.Count + (packageEntries?.Count() ?? 0));
		foreach (PackageEntry item in packageEntries ?? Array.Empty<PackageEntry>())
		{
			AddEntryToPackage(zPackage, item);
		}
		foreach (CustomSyncedValueBase item2 in list2)
		{
			AddEntryToPackage(zPackage, new PackageEntry
			{
				section = "Internal",
				key = item2.Identifier,
				type = item2.Type,
				value = item2.BoxedValue
			});
		}
		foreach (ConfigEntryBase item3 in list)
		{
			AddEntryToPackage(zPackage, new PackageEntry
			{
				section = item3.Definition.Section,
				key = item3.Definition.Key,
				type = configType(item3),
				value = item3.BoxedValue
			});
		}
		return zPackage;
	}

	private static void AddEntryToPackage(ZPackage package, PackageEntry entry)
	{
		package.Write(entry.section);
		package.Write(entry.key);
		package.Write((entry.value == null) ? "" : GetZPackageTypeString(entry.type));
		AddValueToZPackage(package, entry.value);
	}

	private static string GetZPackageTypeString(Type type)
	{
		return type.AssemblyQualifiedName;
	}

	private static void AddValueToZPackage(ZPackage package, [<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(2)] object value)
	{
		Type type = value?.GetType();
		if (value is Enum)
		{
			value = ((IConvertible)value).ToType(Enum.GetUnderlyingType(value.GetType()), CultureInfo.InvariantCulture);
		}
		else
		{
			if (value is ICollection collection)
			{
				package.Write(collection.Count);
				{
					foreach (object item in collection)
					{
						AddValueToZPackage(package, item);
					}
					return;
				}
			}
			if ((object)type != null && type.IsValueType && !type.IsPrimitive)
			{
				FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				package.Write(fields.Length);
				FieldInfo[] array = fields;
				foreach (FieldInfo fieldInfo in array)
				{
					package.Write(GetZPackageTypeString(fieldInfo.FieldType));
					AddValueToZPackage(package, fieldInfo.GetValue(value));
				}
				return;
			}
		}
		ZRpc.Serialize(new object[1] { value }, ref package);
	}

	private static object ReadValueWithTypeFromZPackage(ZPackage package, Type type)
	{
		if ((object)type != null && type.IsValueType && !type.IsPrimitive && !type.IsEnum)
		{
			FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			int num = package.ReadInt();
			if (num != fields.Length)
			{
				throw new InvalidDeserializationTypeException
				{
					received = $"(field count: {num})",
					expected = $"(field count: {fields.Length})"
				};
			}
			object uninitializedObject = FormatterServices.GetUninitializedObject(type);
			FieldInfo[] array = fields;
			foreach (FieldInfo fieldInfo in array)
			{
				string text = package.ReadString();
				if (text != GetZPackageTypeString(fieldInfo.FieldType))
				{
					throw new InvalidDeserializationTypeException
					{
						received = text,
						expected = GetZPackageTypeString(fieldInfo.FieldType),
						field = fieldInfo.Name
					};
				}
				fieldInfo.SetValue(uninitializedObject, ReadValueWithTypeFromZPackage(package, fieldInfo.FieldType));
			}
			return uninitializedObject;
		}
		if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Dictionary<, >))
		{
			int num2 = package.ReadInt();
			IDictionary dictionary = (IDictionary)Activator.CreateInstance(type);
			Type type2 = typeof(KeyValuePair<, >).MakeGenericType(type.GenericTypeArguments);
			FieldInfo field = type2.GetField("key", BindingFlags.Instance | BindingFlags.NonPublic);
			FieldInfo field2 = type2.GetField("value", BindingFlags.Instance | BindingFlags.NonPublic);
			for (int j = 0; j < num2; j++)
			{
				object obj = ReadValueWithTypeFromZPackage(package, type2);
				dictionary.Add(field.GetValue(obj), field2.GetValue(obj));
			}
			return dictionary;
		}
		if (type != typeof(List<string>) && type.IsGenericType)
		{
			Type type3 = typeof(ICollection<>).MakeGenericType(type.GenericTypeArguments[0]);
			if ((object)type3 != null && type3.IsAssignableFrom(type))
			{
				int num3 = package.ReadInt();
				object obj2 = Activator.CreateInstance(type);
				MethodInfo method = type3.GetMethod("Add");
				for (int k = 0; k < num3; k++)
				{
					method.Invoke(obj2, new object[1] { ReadValueWithTypeFromZPackage(package, type.GenericTypeArguments[0]) });
				}
				return obj2;
			}
		}
		ParameterInfo parameterInfo = (ParameterInfo)FormatterServices.GetUninitializedObject(typeof(ParameterInfo));
		AccessTools.DeclaredField(typeof(ParameterInfo), "ClassImpl").SetValue(parameterInfo, type);
		List<object> parameters = new List<object>();
		ZRpc.Deserialize(new ParameterInfo[2] { null, parameterInfo }, package, ref parameters);
		return parameters.First();
	}
}

}


// ---- MistrootTamer.dll :: ServerSync.VersionCheck ----
namespace ServerSync
{
[<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(1)]
[HarmonyPatch]
[PublicAPI]
[<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(0)]
internal class VersionCheck
{
	private static readonly HashSet<VersionCheck> versionChecks;

	private static readonly Dictionary<string, string> notProcessedNames;

	public string Name;

	[<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(2)]
	private string displayName;

	[<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(2)]
	private string currentVersion;

	[<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(2)]
	private string minimumRequiredVersion;

	public bool ModRequired = true;

	[<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(2)]
	private string ReceivedCurrentVersion;

	[<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(2)]
	private string ReceivedMinimumRequiredVersion;

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

	[<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(2)]
	private ConfigSync ConfigSync;

	public string DisplayName
	{
		get
		{
			return displayName ?? Name;
		}
		set
		{
			displayName = value;
		}
	}

	public string CurrentVersion
	{
		get
		{
			return currentVersion ?? "0.0.0";
		}
		set
		{
			currentVersion = value;
		}
	}

	public string MinimumRequiredVersion
	{
		get
		{
			return minimumRequiredVersion ?? (ModRequired ? CurrentVersion : "0.0.0");
		}
		set
		{
			minimumRequiredVersion = value;
		}
	}

	private static void PatchServerSync()
	{
		Patches patchInfo = PatchProcessor.GetPatchInfo(AccessTools.DeclaredMethod(typeof(ZNet), "Awake"));
		if (patchInfo != null && patchInfo.Postfixes.Count([<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(0)] (Patch p) => p.PatchMethod.DeclaringType == typeof(ConfigSync.RegisterRPCPatch)) > 0)
		{
			return;
		}
		Harmony harmony = new Harmony("org.bepinex.helpers.ServerSync");
		foreach (Type item in from t in typeof(ConfigSync).GetNestedTypes(BindingFlags.NonPublic).Concat(new Type[1] { typeof(VersionCheck) })
			where t.IsClass
			select t)
		{
			harmony.PatchAll(item);
		}
	}

	static VersionCheck()
	{
		versionChecks = new HashSet<VersionCheck>();
		notProcessedNames = new Dictionary<string, string>();
		typeof(ThreadingHelper).GetMethod("StartSyncInvoke").Invoke(ThreadingHelper.Instance, new object[1]
		{
			new Action(PatchServerSync)
		});
	}

	public VersionCheck(string name)
	{
		Name = name;
		ModRequired = true;
		versionChecks.Add(this);
	}

	public VersionCheck(ConfigSync configSync)
	{
		ConfigSync = configSync;
		Name = ConfigSync.Name;
		versionChecks.Add(this);
	}

	public void Initialize()
	{
		ReceivedCurrentVersion = null;
		ReceivedMinimumRequiredVersion = null;
		if (ConfigSync != null)
		{
			Name = ConfigSync.Name;
			DisplayName = ConfigSync.DisplayName;
			CurrentVersion = ConfigSync.CurrentVersion;
			MinimumRequiredVersion = ConfigSync.MinimumRequiredVersion;
			ModRequired = ConfigSync.ModRequired;
		}
	}

	private bool IsVersionOk()
	{
		if (ReceivedMinimumRequiredVersion == null || ReceivedCurrentVersion == null)
		{
			return !ModRequired;
		}
		bool flag = new Version(CurrentVersion) >= new Version(ReceivedMinimumRequiredVersion);
		bool flag2 = new Version(ReceivedCurrentVersion) >= new Version(MinimumRequiredVersion);
		return flag && flag2;
	}

	private string ErrorClient()
	{
		if (ReceivedMinimumRequiredVersion == null)
		{
			return DisplayName + " is not installed on the server.";
		}
		return (new Version(CurrentVersion) >= new Version(ReceivedMinimumRequiredVersion)) ? (DisplayName + " may not be higher than version " + ReceivedCurrentVersion + ". You have version " + CurrentVersion + ".") : (DisplayName + " needs to be at least version " + ReceivedMinimumRequiredVersion + ". You have version " + CurrentVersion + ".");
	}

	private string ErrorServer(ZRpc rpc)
	{
		return "Disconnect: The client (" + rpc.GetSocket().GetHostName() + ") doesn't have the correct " + DisplayName + " version " + MinimumRequiredVersion;
	}

	private string Error([<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(2)] ZRpc rpc = null)
	{
		return (rpc == null) ? ErrorClient() : ErrorServer(rpc);
	}

	private static VersionCheck[] GetFailedClient()
	{
		return versionChecks.Where([<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(0)] (VersionCheck check) => !check.IsVersionOk()).ToArray();
	}

	private static VersionCheck[] GetFailedServer(ZRpc rpc)
	{
		return versionChecks.Where([<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(0)] (VersionCheck check) => check.ModRequired && !check.ValidatedClients.Contains(rpc)).ToArray();
	}

	private static void Logout()
	{
		Game.instance.Logout();
		AccessTools.DeclaredField(typeof(ZNet), "m_connectionStatus").SetValue(null, ZNet.ConnectionStatus.ErrorVersion);
	}

	private static void DisconnectClient(ZRpc rpc)
	{
		rpc.Invoke("Error", 3);
	}

	private static void CheckVersion(ZRpc rpc, ZPackage pkg)
	{
		CheckVersion(rpc, pkg, null);
	}

	private static void CheckVersion(ZRpc rpc, ZPackage pkg, [<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(new byte[] { 2, 1, 1 })] Action<ZRpc, ZPackage> original)
	{
		string text = pkg.ReadString();
		string text2 = pkg.ReadString();
		string text3 = pkg.ReadString();
		bool flag = false;
		foreach (VersionCheck versionCheck in versionChecks)
		{
			if (!(text != versionCheck.Name))
			{
				Debug.Log("Received " + versionCheck.DisplayName + " version " + text3 + " and minimum version " + text2 + " from the " + (ZNet.instance.IsServer() ? "client" : "server") + ".");
				versionCheck.ReceivedMinimumRequiredVersion = text2;
				versionCheck.ReceivedCurrentVersion = text3;
				if (ZNet.instance.IsServer() && versionCheck.IsVersionOk())
				{
					versionCheck.ValidatedClients.Add(rpc);
				}
				flag = true;
			}
		}
		if (flag)
		{
			return;
		}
		pkg.SetPos(0);
		if (original != null)
		{
			original(rpc, pkg);
			if (pkg.GetPos() == 0)
			{
				notProcessedNames.Add(text, text3);
			}
		}
	}

	[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
	[HarmonyPrefix]
	private static bool RPC_PeerInfo(ZRpc rpc, ZNet __instance)
	{
		VersionCheck[] array = (__instance.IsServer() ? GetFailedServer(rpc) : GetFailedClient());
		if (array.Length == 0)
		{
			return true;
		}
		VersionCheck[] array2 = array;
		foreach (VersionCheck versionCheck in array2)
		{
			Debug.LogWarning(versionCheck.Error(rpc));
		}
		if (__instance.IsServer())
		{
			DisconnectClient(rpc);
		}
		else
		{
			Logout();
		}
		return false;
	}

	[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
	[HarmonyPrefix]
	private static void RegisterAndCheckVersion(ZNetPeer peer, ZNet __instance)
	{
		notProcessedNames.Clear();
		IDictionary dictionary = (IDictionary)typeof(ZRpc).GetField("m_functions", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(peer.m_rpc);
		if (dictionary.Contains("ServerSync VersionCheck".GetStableHashCode()))
		{
			object obj = dictionary["ServerSync VersionCheck".GetStableHashCode()];
			Action<ZRpc, ZPackage> action = (Action<ZRpc, ZPackage>)obj.GetType().GetField("m_action", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(obj);
			peer.m_rpc.Register("ServerSync VersionCheck", [<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(0)] (ZRpc rpc, [<c2172b6f-9577-4486-9ba5-d0ef05a31635>Nullable(1)] ZPackage pkg) =>
			{
				CheckVersion(rpc, pkg, action);
			});
		}
		else
		{
			peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", CheckVersion);
		}
		foreach (VersionCheck versionCheck in versionChecks)
		{
			versionCheck.Initialize();
			if (versionCheck.ModRequired || __instance.IsServer())
			{
				Debug.Log("Sending " + versionCheck.DisplayName + " version " + versionCheck.CurrentVersion + " and minimum version " + versionCheck.MinimumRequiredVersion + " to the " + (__instance.IsServer() ? "client" : "server") + ".");
				ZPackage zPackage = new ZPackage();
				zPackage.Write(versionCheck.Name);
				zPackage.Write(versionCheck.MinimumRequiredVersion);
				zPackage.Write(versionCheck.CurrentVersion);
				peer.m_rpc.Invoke("ServerSync VersionCheck", zPackage);
			}
		}
	}

	[HarmonyPatch(typeof(ZNet), "Disconnect")]
	[HarmonyPrefix]
	private static void RemoveDisconnected(ZNetPeer peer, ZNet __instance)
	{
		if (!__instance.IsServer())
		{
			return;
		}
		foreach (VersionCheck versionCheck in versionChecks)
		{
			versionCheck.ValidatedClients.Remove(peer.m_rpc);
		}
	}

	[HarmonyPatch(typeof(FejdStartup), "ShowConnectError")]
	[HarmonyPostfix]
	private static void ShowConnectionError(FejdStartup __instance)
	{
		if (!__instance.m_connectionFailedPanel.activeSelf || ZNet.GetConnectionStatus() != ZNet.ConnectionStatus.ErrorVersion)
		{
			return;
		}
		bool flag = false;
		VersionCheck[] failedClient = GetFailedClient();
		if (failedClient.Length != 0)
		{
			string text = string.Join("\n", failedClient.Select([<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(0)] (VersionCheck check) => check.Error()));
			TMP_Text connectionFailedError = __instance.m_connectionFailedError;
			connectionFailedError.text = connectionFailedError.text + "\n" + text;
			flag = true;
		}
		foreach (KeyValuePair<string, string> item in notProcessedNames.OrderBy([<80559ec9-d4af-49dc-b5da-320986fc14b0>NullableContext(0)] (KeyValuePair<string, string> kv) => kv.Key))
		{
			if (!__instance.m_connectionFailedError.text.Contains(item.Key))
			{
				TMP_Text connectionFailedError2 = __instance.m_connectionFailedError;
				connectionFailedError2.text = connectionFailedError2.text + "\nServer expects you to have " + item.Key + " (Version: " + item.Value + ") installed.";
				flag = true;
			}
		}
		if (flag)
		{
			RectTransform component = __instance.m_connectionFailedPanel.transform.Find("Image").GetComponent<RectTransform>();
			Vector2 sizeDelta = component.sizeDelta;
			sizeDelta.x = 675f;
			component.sizeDelta = sizeDelta;
			__instance.m_connectionFailedError.ForceMeshUpdate();
			float num = __instance.m_connectionFailedError.renderedHeight + 105f;
			RectTransform component2 = component.transform.Find("ButtonOk").GetComponent<RectTransform>();
			component2.anchoredPosition = new Vector2(component2.anchoredPosition.x, component2.anchoredPosition.y - (num - component.sizeDelta.y) / 2f);
			sizeDelta = component.sizeDelta;
			sizeDelta.y = num;
			component.sizeDelta = sizeDelta;
		}
	}
}

}


// ---- MistrootTamer.dll :: PieceManager.MaterialReplacer ----
namespace PieceManager
{
[<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(1)]
[<130f0e86-0392-462a-ad1d-c07a91e49931>Nullable(0)]
[PublicAPI]
internal static class MaterialReplacer
{
	[<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(0)]
	public enum ShaderType
	{
		PieceShader,
		VegetationShader,
		RockShader,
		RugShader,
		GrassShader,
		CustomCreature,
		UseUnityShader
	}

	private static readonly Dictionary<GameObject, bool> ObjectToSwap;

	private static readonly Dictionary<string, Material> OriginalMaterials;

	private static readonly Dictionary<GameObject, ShaderType> ObjectsForShaderReplace;

	private static readonly HashSet<Shader> CachedShaders;

	private static bool hasRun;

	static MaterialReplacer()
	{
		CachedShaders = new HashSet<Shader>();
		hasRun = false;
		OriginalMaterials = new Dictionary<string, Material>();
		ObjectToSwap = new Dictionary<GameObject, bool>();
		ObjectsForShaderReplace = new Dictionary<GameObject, ShaderType>();
		new Harmony("org.bepinex.helpers.PieceManager").Patch(AccessTools.DeclaredMethod(typeof(ZoneSystem), "Start"), null, new HarmonyMethod(typeof(MaterialReplacer), "ReplaceAllMaterialsWithOriginal"));
	}

	public static void RegisterGameObjectForShaderSwap(GameObject go, ShaderType type)
	{
		if (!ObjectsForShaderReplace.ContainsKey(go))
		{
			ObjectsForShaderReplace.Add(go, type);
		}
	}

	public static void RegisterGameObjectForMatSwap(GameObject go, bool isJotunnMock = false)
	{
		if (!ObjectToSwap.ContainsKey(go))
		{
			ObjectToSwap.Add(go, isJotunnMock);
		}
	}

	private static void GetAllMaterials()
	{
		Material[] array = Resources.FindObjectsOfTypeAll<Material>();
		foreach (Material material in array)
		{
			OriginalMaterials[material.name] = material;
		}
	}

	[HarmonyPriority(700)]
	private static void ReplaceAllMaterialsWithOriginal()
	{
		if (SystemInfo.graphicsDeviceType == GraphicsDeviceType.Null || hasRun)
		{
			return;
		}
		if (OriginalMaterials.Count == 0)
		{
			GetAllMaterials();
		}
		foreach (KeyValuePair<GameObject, bool> item in ObjectToSwap)
		{
			GameObject key = item.Key;
			bool value = item.Value;
			ProcessGameObjectMaterials(key, value);
		}
		AssetBundle[] array = Resources.FindObjectsOfTypeAll<AssetBundle>();
		foreach (AssetBundle assetBundle in array)
		{
			IEnumerable<Shader> enumerable3;
			try
			{
				IEnumerable<Shader> enumerable2;
				if (!assetBundle.isStreamedSceneAssetBundle || !assetBundle)
				{
					IEnumerable<Shader> enumerable = assetBundle.LoadAllAssets<Shader>();
					enumerable2 = enumerable;
				}
				else
				{
					enumerable2 = from shader in assetBundle.GetAllAssetNames().Select(assetBundle.LoadAsset<Shader>)
						where shader != null
						select shader;
				}
				enumerable3 = enumerable2;
			}
			catch (Exception)
			{
				continue;
			}
			if (enumerable3 == null)
			{
				continue;
			}
			foreach (Shader item2 in enumerable3)
			{
				CachedShaders.Add(item2);
			}
		}
		foreach (KeyValuePair<GameObject, ShaderType> item3 in ObjectsForShaderReplace)
		{
			GameObject key2 = item3.Key;
			ShaderType value2 = item3.Value;
			ProcessGameObjectShaders(key2, value2);
		}
		hasRun = true;
	}

	private static void ProcessGameObjectMaterials(GameObject go, bool isJotunnMock)
	{
		Renderer[] componentsInChildren = go.GetComponentsInChildren<Renderer>(includeInactive: true);
		foreach (Renderer obj in componentsInChildren)
		{
			Material[] sharedMaterials = obj.sharedMaterials.Select([<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(0)] (Material material) => ReplaceMaterial(material, isJotunnMock)).ToArray();
			obj.sharedMaterials = sharedMaterials;
		}
	}

	private static Material ReplaceMaterial(Material originalMaterial, bool isJotunnMock)
	{
		string text = (isJotunnMock ? "JVLmock_" : "_REPLACE_");
		if (!originalMaterial.name.StartsWith(text, StringComparison.Ordinal))
		{
			return originalMaterial;
		}
		string text2 = originalMaterial.name.Replace(" (Instance)", "").Replace(text, "");
		if (OriginalMaterials.TryGetValue(text2, out var value))
		{
			return value;
		}
		Debug.LogWarning("No suitable material found to replace: " + text2);
		return originalMaterial;
	}

	private static void ProcessGameObjectShaders(GameObject go, ShaderType shaderType)
	{
		Renderer[] componentsInChildren = go.GetComponentsInChildren<Renderer>(includeInactive: true);
		for (int i = 0; i < componentsInChildren.Length; i++)
		{
			Material[] sharedMaterials = componentsInChildren[i].sharedMaterials;
			foreach (Material material in sharedMaterials)
			{
				if (material != null)
				{
					material.shader = GetShaderForType(material.shader, shaderType, material.shader.name);
				}
			}
		}
	}

	private static Shader GetShaderForType(Shader orig, ShaderType shaderType, string originalShaderName)
	{
		return shaderType switch
		{
			ShaderType.PieceShader => FindShaderWithName(orig, "Custom/Piece"), 
			ShaderType.VegetationShader => FindShaderWithName(orig, "Custom/Vegetation"), 
			ShaderType.RockShader => FindShaderWithName(orig, "Custom/StaticRock"), 
			ShaderType.RugShader => FindShaderWithName(orig, "Custom/Rug"), 
			ShaderType.GrassShader => FindShaderWithName(orig, "Custom/Grass"), 
			ShaderType.CustomCreature => FindShaderWithName(orig, "Custom/Creature"), 
			ShaderType.UseUnityShader => FindShaderWithName(orig, (FindShaderWithName(orig, originalShaderName) != null) ? originalShaderName : "ToonDeferredShading2017"), 
			_ => FindShaderWithName(orig, "Standard"), 
		};
	}

	public static Shader FindShaderWithName(Shader origShader, string name)
	{
		foreach (Shader cachedShader in CachedShaders)
		{
			if (cachedShader.name == name)
			{
				return cachedShader;
			}
		}
		return origShader;
	}
}

}


// ---- MistrootTamer.dll :: PieceManager.CraftingTable ----
namespace PieceManager
{
[PublicAPI]
internal enum CraftingTable
{
	None,
	[InternalName("piece_workbench")]
	Workbench,
	[InternalName("piece_cauldron")]
	Cauldron,
	[InternalName("forge")]
	Forge,
	[InternalName("piece_artisanstation")]
	ArtisanTable,
	[InternalName("piece_stonecutter")]
	StoneCutter,
	[InternalName("piece_magetable")]
	MageTable,
	[InternalName("blackforge")]
	BlackForge,
	[InternalName("piece_preptable")]
	FoodPreparationTable,
	[InternalName("piece_MeadCauldron")]
	MeadKetill,
	Custom
}

}


// ---- MistrootTamer.dll :: PieceManager.InternalName ----
namespace PieceManager
{
[<130f0e86-0392-462a-ad1d-c07a91e49931>Nullable(0)]
[<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(1)]
internal class InternalName : Attribute
{
	public readonly string internalName;

	public InternalName(string internalName)
	{
		this.internalName = internalName;
	}
}

}


// ---- MistrootTamer.dll :: PieceManager.ExtensionList ----
namespace PieceManager
{
[PublicAPI]
[<130f0e86-0392-462a-ad1d-c07a91e49931>Nullable(0)]
[<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(1)]
internal class ExtensionList
{
	public readonly List<ExtensionConfig> ExtensionStations = new List<ExtensionConfig>();

	public void Set(CraftingTable table, int maxStationDistance = 5)
	{
		ExtensionStations.Add(new ExtensionConfig
		{
			Table = table,
			maxStationDistance = maxStationDistance
		});
	}

	public void Set(string customTable, int maxStationDistance = 5)
	{
		ExtensionStations.Add(new ExtensionConfig
		{
			Table = CraftingTable.Custom,
			custom = customTable,
			maxStationDistance = maxStationDistance
		});
	}
}

}


// ---- MistrootTamer.dll :: PieceManager.ExtensionConfig ----
namespace PieceManager
{
internal struct ExtensionConfig
{
	public CraftingTable Table;

	public float maxStationDistance;

	[<130f0e86-0392-462a-ad1d-c07a91e49931>Nullable(2)]
	public string custom;
}

}


// ---- MistrootTamer.dll :: PieceManager.CraftingStationList ----
namespace PieceManager
{
[<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(1)]
[<130f0e86-0392-462a-ad1d-c07a91e49931>Nullable(0)]
[PublicAPI]
internal class CraftingStationList
{
	public readonly List<CraftingStationConfig> Stations = new List<CraftingStationConfig>();

	public void Set(CraftingTable table)
	{
		Stations.Add(new CraftingStationConfig
		{
			Table = table
		});
	}

	public void Set(string customTable)
	{
		Stations.Add(new CraftingStationConfig
		{
			Table = CraftingTable.Custom,
			custom = customTable
		});
	}
}

}


// ---- MistrootTamer.dll :: PieceManager.CraftingStationConfig ----
namespace PieceManager
{
internal struct CraftingStationConfig
{
	public CraftingTable Table;

	public int level;

	[<130f0e86-0392-462a-ad1d-c07a91e49931>Nullable(2)]
	public string custom;
}

}


// ---- MistrootTamer.dll :: PieceManager.BuildPieceCategory ----
namespace PieceManager
{
[PublicAPI]
internal enum BuildPieceCategory
{
	Misc = 0,
	Crafting = 1,
	BuildingWorkbench = 2,
	BuildingStonecutter = 3,
	Furniture = 4,
	All = 100,
	Custom = 99
}

}


// ---- MistrootTamer.dll :: PieceManager.RequiredResourcesList ----
namespace PieceManager
{
[<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(1)]
[PublicAPI]
[<130f0e86-0392-462a-ad1d-c07a91e49931>Nullable(0)]
internal class RequiredResourcesList
{
	public readonly List<Requirement> Requirements = new List<Requirement>();

	public void Add(string item, int amount, bool recover)
	{
		Requirements.Add(new Requirement
		{
			itemName = item,
			amount = amount,
			recover = recover
		});
	}
}

}


// ---- MistrootTamer.dll :: PieceManager.Requirement ----
namespace PieceManager
{
internal struct Requirement
{
	[<130f0e86-0392-462a-ad1d-c07a91e49931>Nullable(1)]
	public string itemName;

	public int amount;

	public bool recover;
}

}


// ---- MistrootTamer.dll :: PieceManager.SpecialProperties ----
namespace PieceManager
{
internal struct SpecialProperties
{
	[Description("Admins should be the only ones that can build this piece.")]
	public bool AdminOnly;

	[Description("Turns off generating a config for this build piece.")]
	public bool NoConfig;
}

}


// ---- MistrootTamer.dll :: PieceManager.BuildingPieceCategory ----
namespace PieceManager
{
[<130f0e86-0392-462a-ad1d-c07a91e49931>Nullable(0)]
[PublicAPI]
[<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(1)]
internal class BuildingPieceCategory
{
	public BuildPieceCategory Category;

	public string custom = "";

	public void Set(BuildPieceCategory category)
	{
		Category = category;
	}

	public void Set(string customCategory)
	{
		Category = BuildPieceCategory.Custom;
		custom = customCategory;
	}
}

}


// ---- MistrootTamer.dll :: PieceManager.PieceTool ----
namespace PieceManager
{
[<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(1)]
[PublicAPI]
[<130f0e86-0392-462a-ad1d-c07a91e49931>Nullable(0)]
internal class PieceTool
{
	public readonly HashSet<string> Tools = new HashSet<string>();

	public void Add(string tool)
	{
		Tools.Add(tool);
	}
}

}


// ---- MistrootTamer.dll :: PieceManager.BuildPiece ----
namespace PieceManager
{
[<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(1)]
[<130f0e86-0392-462a-ad1d-c07a91e49931>Nullable(0)]
[PublicAPI]
internal class BuildPiece
{
	[<130f0e86-0392-462a-ad1d-c07a91e49931>Nullable(0)]
	internal class PieceConfig
	{
		public ConfigEntry<string> craft;

		public ConfigEntry<BuildPieceCategory> category;

		public ConfigEntry<string> customCategory;

		public ConfigEntry<string> tools;

		public ConfigEntry<CraftingTable> extensionTable;

		public ConfigEntry<string> customExtentionTable;

		public ConfigEntry<float> maxStationDistance;

		public ConfigEntry<CraftingTable> table;

		public ConfigEntry<string> customTable;
	}

	[<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(0)]
	private class ConfigurationManagerAttributes
	{
		[UsedImplicitly]
		public int? Order;

		[UsedImplicitly]
		public bool? Browsable;

		[<130f0e86-0392-462a-ad1d-c07a91e49931>Nullable(2)]
		[UsedImplicitly]
		public string Category;

		[UsedImplicitly]
		[<130f0e86-0392-462a-ad1d-c07a91e49931>Nullable(new byte[] { 2, 1 })]
		public Action<ConfigEntryBase> CustomDrawer;
	}

	[<130f0e86-0392-462a-ad1d-c07a91e49931>Nullable(0)]
	private class SerializedRequirements
	{
		public readonly List<Requirement> Reqs;

		public SerializedRequirements(List<Requirement> reqs)
		{
			Reqs = reqs;
		}

		public SerializedRequirements(string reqs)
		{
			Reqs = reqs.Split(new char[1] { ',' }).Select([<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(0)] (string r) =>
			{
				string[] array = r.Split(new char[1] { ':' });
				int result;
				bool result2 = default(bool);
				return new Requirement
				{
					itemName = array[0],
					amount = ((array.Length <= 1 || !int.TryParse(array[1], out result)) ? 1 : result),
					recover = (array.Length <= 2 || !bool.TryParse(array[2], out result2) || result2)
				};
			}).ToList();
		}

		public override string ToString()
		{
			return string.Join(",", Reqs.Select([<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(0)] (Requirement r) => $"{r.itemName}:{r.amount}:{r.recover}"));
		}

		[return: <130f0e86-0392-462a-ad1d-c07a91e49931>Nullable(2)]
		public static ItemDrop fetchByName(ObjectDB objectDB, string name)
		{
			ItemDrop obj = objectDB.GetItemPrefab(name)?.GetComponent<ItemDrop>();
			if (obj == null)
			{
				Debug.LogWarning(((!string.IsNullOrWhiteSpace(plugin.name)) ? ("[" + plugin.name + "]") : "") + " The required item '" + name + "' does not exist.");
			}
			return obj;
		}

		public static Piece.Requirement[] toPieceReqs(SerializedRequirements craft)
		{
			return craft.Reqs.Where((Requirement r) => r.itemName != "").ToDictionary([<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(0)] (Requirement r) => r.itemName, [<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(0)] (Requirement r) =>
			{
				ItemDrop itemDrop = ResItem(r);
				return ((object)itemDrop == null) ? null : new Piece.Requirement
				{
					m_amount = r.amount,
					m_resItem = itemDrop,
					m_recover = r.recover
				};
			}).Values.Where([<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(0)] (Piece.Requirement v) => v != null).ToArray();
			[<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(2)]
			static ItemDrop ResItem(Requirement r)
			{
				return fetchByName(ObjectDB.instance, r.itemName);
			}
		}
	}

	internal static readonly List<BuildPiece> registeredPieces = new List<BuildPiece>();

	private static readonly Dictionary<Piece, BuildPiece> pieceMap = new Dictionary<Piece, BuildPiece>();

	internal static Dictionary<BuildPiece, PieceConfig> pieceConfigs = new Dictionary<BuildPiece, PieceConfig>();

	internal List<Conversion> Conversions = new List<Conversion>();

	internal List<Smelter.ItemConversion> conversions = new List<Smelter.ItemConversion>();

	[Description("Disables generation of the configs for your pieces. This is global, this turns it off for all pieces in your mod.")]
	public static bool ConfigurationEnabled = true;

	public readonly GameObject Prefab;

	[Description("Specifies the resources needed to craft the piece.\nUse .Add to add resources with their internal ID and an amount.\nUse one .Add for each resource type the building piece should need.")]
	public readonly RequiredResourcesList RequiredItems = new RequiredResourcesList();

	[Description("Sets the category for the building piece.")]
	public readonly BuildingPieceCategory Category = new BuildingPieceCategory();

	[Description("Specifies the tool needed to build your piece.\nUse .Add to add a tool.")]
	public readonly PieceTool Tool = new PieceTool();

	[Description("Specifies the crafting station needed to build your piece.\nUse .Add to add a crafting station, using the CraftingTable enum and a minimum level for the crafting station.")]
	public CraftingStationList Crafting = new CraftingStationList();

	[Description("Makes this piece a station extension")]
	public ExtensionList Extension = new ExtensionList();

	[Description("Change the extended/special properties of your build piece.")]
	public SpecialProperties SpecialProperties;

	[Description("Specifies a config entry which toggles whether a recipe is active.")]
	[<130f0e86-0392-462a-ad1d-c07a91e49931>Nullable(2)]
	public ConfigEntryBase RecipeIsActive;

	[<130f0e86-0392-462a-ad1d-c07a91e49931>Nullable(2)]
	private LocalizeKey _name;

	[<130f0e86-0392-462a-ad1d-c07a91e49931>Nullable(2)]
	private LocalizeKey _description;

	internal string[] activeTools;

	[<130f0e86-0392-462a-ad1d-c07a91e49931>Nullable(2)]
	private static object configManager;

	[<130f0e86-0392-462a-ad1d-c07a91e49931>Nullable(2)]
	private static Localization _english;

	[<130f0e86-0392-462a-ad1d-c07a91e49931>Nullable(2)]
	internal static BaseUnityPlugin _plugin = null;

	private static bool hasConfigSync = true;

	[<130f0e86-0392-462a-ad1d-c07a91e49931>Nullable(2)]
	private static object _configSync;

	public LocalizeKey Name
	{
		get
		{
			LocalizeKey name = _name;
			if (name != null)
			{
				return name;
			}
			Piece component = Prefab.GetComponent<Piece>();
			if (component.m_name.StartsWith("$"))
			{
				_name = new LocalizeKey(component.m_name);
			}
			else
			{
				string text = "$piece_" + Prefab.name.Replace(" ", "_");
				_name = new LocalizeKey(text).English(component.m_name);
				component.m_name = text;
			}
			return _name;
		}
	}

	public LocalizeKey Description
	{
		get
		{
			LocalizeKey description = _description;
			if (description != null)
			{
				return description;
			}
			Piece component = Prefab.GetComponent<Piece>();
			if (component.m_description.StartsWith("$"))
			{
				_description = new LocalizeKey(component.m_description);
			}
			else
			{
				string text = "$piece_" + Prefab.name.Replace(" ", "_") + "_description";
				_description = new LocalizeKey(text).English(component.m_description);
				component.m_description = text;
			}
			return _description;
		}
	}

	private static Localization english => _english ?? (_english = LocalizationCache.ForLanguage("English"));

	internal static BaseUnityPlugin plugin
	{
		get
		{
			if ((object)_plugin != null)
			{
				return _plugin;
			}
			IEnumerable<TypeInfo> source;
			try
			{
				source = Assembly.GetExecutingAssembly().DefinedTypes.ToList();
			}
			catch (ReflectionTypeLoadException ex)
			{
				source = from t in ex.Types
					where t != null
					select t.GetTypeInfo();
			}
			_plugin = (BaseUnityPlugin)Chainloader.ManagerObject.GetComponent(source.First([<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(0)] (TypeInfo t) => t.IsClass && typeof(BaseUnityPlugin).IsAssignableFrom(t)));
			return _plugin;
		}
	}

	[<130f0e86-0392-462a-ad1d-c07a91e49931>Nullable(2)]
	private static object configSync
	{
		[<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(2)]
		get
		{
			if (_configSync != null || !hasConfigSync)
			{
				return _configSync;
			}
			Type type = Assembly.GetExecutingAssembly().GetType("ServerSync.ConfigSync");
			if ((object)type != null)
			{
				_configSync = Activator.CreateInstance(type, plugin.Info.Metadata.GUID + " PieceManager");
				type.GetField("CurrentVersion").SetValue(_configSync, plugin.Info.Metadata.Version.ToString());
				type.GetProperty("IsLocked").SetValue(_configSync, true);
			}
			else
			{
				hasConfigSync = false;
			}
			return _configSync;
		}
	}

	public BuildPiece(string assetBundleFileName, string prefabName, string folderName = "assets")
		: this(PiecePrefabManager.RegisterAssetBundle(assetBundleFileName, folderName), prefabName)
	{
	}

	public BuildPiece(AssetBundle bundle, string prefabName)
	{
		Prefab = PiecePrefabManager.RegisterPrefab(bundle, prefabName);
		registeredPieces.Add(this);
	}

	internal static void Patch_FejdStartup(FejdStartup __instance)
	{
		Type configManagerType = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault([<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(0)] (Assembly a) => a.GetName().Name == "ConfigurationManager")?.GetType("ConfigurationManager.ConfigurationManager");
		configManager = ((configManagerType == null) ? null : Chainloader.ManagerObject.GetComponent(configManagerType));
		foreach (BuildPiece registeredPiece in registeredPieces)
		{
			registeredPiece.activeTools = registeredPiece.Tool.Tools.DefaultIfEmpty("Hammer").ToArray();
			if (registeredPiece.Category.Category != BuildPieceCategory.Custom)
			{
				registeredPiece.Prefab.GetComponent<Piece>().m_category = (Piece.PieceCategory)registeredPiece.Category.Category;
			}
			else
			{
				registeredPiece.Prefab.GetComponent<Piece>().m_category = PiecePrefabManager.GetCategory(registeredPiece.Category.custom);
			}
		}
		if (!ConfigurationEnabled)
		{
			return;
		}
		bool saveOnConfigSet = plugin.Config.SaveOnConfigSet;
		plugin.Config.SaveOnConfigSet = false;
		foreach (BuildPiece registeredPiece2 in registeredPieces)
		{
			BuildPiece piece = registeredPiece2;
			if (piece.SpecialProperties.NoConfig)
			{
				continue;
			}
			PieceConfig pieceConfig = (pieceConfigs[piece] = new PieceConfig());
			PieceConfig cfg = pieceConfig;
			Piece piecePrefab = piece.Prefab.GetComponent<Piece>();
			string pieceName = piecePrefab.m_name;
			string englishName = new Regex("[=\\n\\t\\\\\"\\'\\[\\]]*").Replace(english.Localize(pieceName), "").Trim();
			string localizedName = Localization.instance.Localize(pieceName).Trim();
			int order = 0;
			cfg.category = config(englishName, "Build Table Category", piece.Category.Category, new ConfigDescription("Build Category where " + localizedName + " is available.", null, new ConfigurationManagerAttributes
			{
				Order = (order -= 1),
				Category = localizedName
			}));
			ConfigurationManagerAttributes customTableAttributes = new ConfigurationManagerAttributes
			{
				Order = (order -= 1),
				Browsable = (cfg.category.Value == BuildPieceCategory.Custom),
				Category = localizedName
			};
			cfg.customCategory = config(englishName, "Custom Build Category", piece.Category.custom, new ConfigDescription("", null, customTableAttributes));
			cfg.category.SettingChanged += BuildTableConfigChanged;
			cfg.customCategory.SettingChanged += BuildTableConfigChanged;
			if (cfg.category.Value == BuildPieceCategory.Custom)
			{
				piecePrefab.m_category = PiecePrefabManager.GetCategory(cfg.customCategory.Value);
			}
			else
			{
				piecePrefab.m_category = (Piece.PieceCategory)cfg.category.Value;
			}
			cfg.tools = config(englishName, "Tools", string.Join(", ", piece.activeTools), new ConfigDescription("Comma separated list of tools where " + localizedName + " is available.", null, customTableAttributes));
			piece.activeTools = (from s in cfg.tools.Value.Split(new char[1] { ',' })
				select s.Trim()).ToArray();
			cfg.tools.SettingChanged += [<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(0)] (object _, EventArgs _) =>
			{
				Inventory[] source = (from c in Player.s_players.Select([<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(0)] (Player p) => p.GetInventory()).Concat(from c in UnityEngine.Object.FindObjectsOfType<Container>()
						select c.GetInventory())
					where c != null
					select c).ToArray();
				Dictionary<string, List<PieceTable>> dictionary = (from kv in (from i in (from p in ObjectDB.instance.m_items
							select p.GetComponent<ItemDrop>() into c
							where (bool)c && (bool)c.GetComponent<ZNetView>()
							select c).Concat(ItemDrop.s_instances)
						select new KeyValuePair<string, ItemDrop.ItemData>(Utils.GetPrefabName(i.gameObject), i.m_itemData)).Concat(from i in source.SelectMany([<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(0)] (Inventory i) => i.GetAllItems())
						select new KeyValuePair<string, ItemDrop.ItemData>(i.m_dropPrefab.name, i))
					where kv.Value.m_shared.m_buildPieces
					group kv by kv.Key).ToDictionary([<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(0)] (IGrouping<string, KeyValuePair<string, ItemDrop.ItemData>> g) => g.Key, [<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(0)] (IGrouping<string, KeyValuePair<string, ItemDrop.ItemData>> g) => g.Select([<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(0)] (KeyValuePair<string, ItemDrop.ItemData> kv) => kv.Value.m_shared.m_buildPieces).Distinct().ToList());
				string[] array4 = piece.activeTools;
				foreach (string key in array4)
				{
					if (dictionary.TryGetValue(key, out var value))
					{
						foreach (PieceTable item3 in value)
						{
							item3.m_pieces.Remove(piece.Prefab);
						}
					}
				}
				piece.activeTools = (from s in cfg.tools.Value.Split(new char[1] { ',' })
					select s.Trim()).ToArray();
				if ((bool)ObjectDB.instance)
				{
					array4 = piece.activeTools;
					foreach (string key2 in array4)
					{
						if (dictionary.TryGetValue(key2, out var value2))
						{
							foreach (PieceTable item4 in value2)
							{
								if (!item4.m_pieces.Contains(piece.Prefab))
								{
									item4.m_pieces.Add(piece.Prefab);
								}
							}
						}
					}
					if ((bool)Player.m_localPlayer && (bool)Player.m_localPlayer.m_buildPieces)
					{
						PiecePrefabManager.CategoryRefreshNeeded = true;
						((Humanoid)Player.m_localPlayer).SetPlaceMode(Player.m_localPlayer.m_buildPieces);
					}
				}
			};
			StationExtension pieceExtensionComp;
			List<ConfigurationManagerAttributes> hideWhenNoneAttributes;
			if (piece.Extension.ExtensionStations.Count > 0)
			{
				pieceExtensionComp = piece.Prefab.GetOrAddComponent<StationExtension>();
				PieceConfig pieceConfig3 = cfg;
				string text = englishName;
				CraftingTable table = piece.Extension.ExtensionStations.First().Table;
				string description = "Crafting station that " + localizedName + " extends.";
				object[] array = new object[1];
				ConfigurationManagerAttributes configurationManagerAttributes = new ConfigurationManagerAttributes();
				int num = order - 1;
				order = num;
				configurationManagerAttributes.Order = num;
				array[0] = configurationManagerAttributes;
				pieceConfig3.extensionTable = config(text, "Extends Station", table, new ConfigDescription(description, null, array));
				cfg.customExtentionTable = config(englishName, "Custom Extend Station", piece.Extension.ExtensionStations.First().custom ?? "", new ConfigDescription("", null, customTableAttributes));
				PieceConfig pieceConfig4 = cfg;
				string text2 = englishName;
				float maxStationDistance = piece.Extension.ExtensionStations.First().maxStationDistance;
				string description2 = "Distance from the station that " + localizedName + " can be placed.";
				object[] array2 = new object[1];
				ConfigurationManagerAttributes configurationManagerAttributes2 = new ConfigurationManagerAttributes();
				num = order - 1;
				order = num;
				configurationManagerAttributes2.Order = num;
				array2[0] = configurationManagerAttributes2;
				pieceConfig4.maxStationDistance = config(text2, "Max Station Distance", maxStationDistance, new ConfigDescription(description2, null, array2));
				hideWhenNoneAttributes = new List<ConfigurationManagerAttributes>();
				cfg.extensionTable.SettingChanged += ExtensionTableConfigChanged;
				cfg.customExtentionTable.SettingChanged += ExtensionTableConfigChanged;
				cfg.maxStationDistance.SettingChanged += ExtensionTableConfigChanged;
				ConfigurationManagerAttributes configurationManagerAttributes3 = new ConfigurationManagerAttributes();
				num = order - 1;
				order = num;
				configurationManagerAttributes3.Order = num;
				configurationManagerAttributes3.Browsable = cfg.extensionTable.Value != CraftingTable.None;
				ConfigurationManagerAttributes item = configurationManagerAttributes3;
				hideWhenNoneAttributes.Add(item);
			}
			List<ConfigurationManagerAttributes> hideWhenNoneAttributes2;
			if (piece.Crafting.Stations.Count > 0)
			{
				hideWhenNoneAttributes2 = new List<ConfigurationManagerAttributes>();
				PieceConfig pieceConfig5 = cfg;
				string text3 = englishName;
				CraftingTable table2 = piece.Crafting.Stations.First().Table;
				string description3 = "Crafting station where " + localizedName + " is available.";
				object[] array3 = new object[1];
				ConfigurationManagerAttributes configurationManagerAttributes4 = new ConfigurationManagerAttributes();
				int num = order - 1;
				order = num;
				configurationManagerAttributes4.Order = num;
				array3[0] = configurationManagerAttributes4;
				pieceConfig5.table = config(text3, "Crafting Station", table2, new ConfigDescription(description3, null, array3));
				cfg.customTable = config(englishName, "Custom Crafting Station", piece.Crafting.Stations.First().custom ?? "", new ConfigDescription("", null, customTableAttributes));
				cfg.table.SettingChanged += TableConfigChanged;
				cfg.customTable.SettingChanged += TableConfigChanged;
				ConfigurationManagerAttributes configurationManagerAttributes5 = new ConfigurationManagerAttributes();
				num = order - 1;
				order = num;
				configurationManagerAttributes5.Order = num;
				configurationManagerAttributes5.Browsable = cfg.table.Value != CraftingTable.None;
				ConfigurationManagerAttributes item2 = configurationManagerAttributes5;
				hideWhenNoneAttributes2.Add(item2);
			}
			cfg.craft = itemConfig("Crafting Costs", new SerializedRequirements(piece.RequiredItems.Requirements).ToString(), "Item costs to craft " + localizedName);
			cfg.craft.SettingChanged += [<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(0)] (object _, EventArgs _) =>
			{
				if ((bool)ObjectDB.instance && ObjectDB.instance.GetItemPrefab("YmirRemains") != null)
				{
					Piece.Requirement[] resources = SerializedRequirements.toPieceReqs(new SerializedRequirements(cfg.craft.Value));
					piecePrefab.m_resources = resources;
					Piece[] array4 = UnityEngine.Object.FindObjectsOfType<Piece>();
					foreach (Piece piece2 in array4)
					{
						if (piece2.m_name == pieceName)
						{
							piece2.m_resources = resources;
						}
					}
				}
			};
			for (int num2 = 0; num2 < piece.Conversions.Count; num2++)
			{
				string text4 = ((piece.Conversions.Count > 1) ? $"{num2 + 1}. " : "");
				Conversion conversion = piece.Conversions[num2];
				conversion.config = new Conversion.ConversionConfig();
				int index = num2;
				conversion.config.input = config(englishName, text4 + "Conversion Input Item", conversion.Input, new ConfigDescription("Conversion input item within " + englishName, null, new ConfigurationManagerAttributes
				{
					Category = localizedName
				}));
				conversion.config.input.SettingChanged += [<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(0)] (object _, EventArgs _) =>
				{
					if (index < piece.conversions.Count)
					{
						ObjectDB instance = ObjectDB.instance;
						if ((object)instance != null)
						{
							ItemDrop itemDrop = SerializedRequirements.fetchByName(instance, conversion.config.input.Value);
							piece.conversions[index].m_from = itemDrop;
						}
					}
				};
				conversion.config.output = config(englishName, text4 + "Conversion Output Item", conversion.Output, new ConfigDescription("Conversion output item within " + englishName, null, new ConfigurationManagerAttributes
				{
					Category = localizedName
				}));
				conversion.config.output.SettingChanged += [<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(0)] (object _, EventArgs _) =>
				{
					if (index < piece.conversions.Count)
					{
						ObjectDB instance = ObjectDB.instance;
						if ((object)instance != null)
						{
							ItemDrop to = SerializedRequirements.fetchByName(instance, conversion.config.output.Value);
							piece.conversions[index].m_to = to;
						}
					}
				};
			}
			void BuildTableConfigChanged(object o, EventArgs e)
			{
				if (registeredPieces.Count > 0)
				{
					if (cfg.category.Value == BuildPieceCategory.Custom)
					{
						piecePrefab.m_category = PiecePrefabManager.GetCategory(cfg.customCategory.Value);
					}
					else
					{
						piecePrefab.m_category = (Piece.PieceCategory)cfg.category.Value;
					}
					if ((bool)Hud.instance)
					{
						PiecePrefabManager.CategoryRefreshNeeded = true;
						PiecePrefabManager.CreateCategoryTabs();
					}
				}
				customTableAttributes.Browsable = cfg.category.Value == BuildPieceCategory.Custom;
				ReloadConfigDisplay();
			}
			void ExtensionTableConfigChanged(object o, EventArgs e)
			{
				if (piece.RequiredItems.Requirements.Count > 0)
				{
					if (cfg.extensionTable.Value == CraftingTable.Custom)
					{
						pieceExtensionComp.m_craftingStation = ZNetScene.instance.GetPrefab(cfg.customExtentionTable.Value)?.GetComponent<CraftingStation>();
					}
					else
					{
						pieceExtensionComp.m_craftingStation = ZNetScene.instance.GetPrefab(((InternalName)typeof(CraftingTable).GetMember(cfg.extensionTable.Value.ToString())[0].GetCustomAttributes(typeof(InternalName)).First()).internalName).GetComponent<CraftingStation>();
					}
					pieceExtensionComp.m_maxStationDistance = cfg.maxStationDistance.Value;
				}
				customTableAttributes.Browsable = cfg.extensionTable.Value == CraftingTable.Custom;
				foreach (ConfigurationManagerAttributes item5 in hideWhenNoneAttributes)
				{
					item5.Browsable = cfg.extensionTable.Value != CraftingTable.None;
				}
				ReloadConfigDisplay();
				plugin.Config.Save();
			}
			ConfigEntry<string> itemConfig(string name, string value, string desc)
			{
				ConfigurationManagerAttributes configurationManagerAttributes6 = new ConfigurationManagerAttributes
				{
					CustomDrawer = DrawConfigTable,
					Order = (order -= 1),
					Category = localizedName
				};
				return config(englishName, name, value, new ConfigDescription(desc, null, configurationManagerAttributes6));
			}
			void TableConfigChanged(object o, EventArgs e)
			{
				if (piece.RequiredItems.Requirements.Count > 0)
				{
					switch (cfg.table.Value)
					{
					case CraftingTable.None:
						piecePrefab.m_craftingStation = null;
						break;
					case CraftingTable.Custom:
						piecePrefab.m_craftingStation = ZNetScene.instance.GetPrefab(cfg.customTable.Value)?.GetComponent<CraftingStation>();
						break;
					default:
						piecePrefab.m_craftingStation = ZNetScene.instance.GetPrefab(((InternalName)typeof(CraftingTable).GetMember(cfg.table.Value.ToString())[0].GetCustomAttributes(typeof(InternalName)).First()).internalName).GetComponent<CraftingStation>();
						break;
					}
				}
				customTableAttributes.Browsable = cfg.table.Value == CraftingTable.Custom;
				foreach (ConfigurationManagerAttributes item6 in hideWhenNoneAttributes2)
				{
					item6.Browsable = cfg.table.Value != CraftingTable.None;
				}
				ReloadConfigDisplay();
				plugin.Config.Save();
			}
		}
		foreach (BuildPiece registeredPiece3 in registeredPieces)
		{
			ConfigEntryBase enabledCfg = registeredPiece3.RecipeIsActive;
			Piece piecePrefab2;
			if (enabledCfg != null)
			{
				piecePrefab2 = registeredPiece3.Prefab.GetComponent<Piece>();
				ConfigChanged(null, null);
				enabledCfg.GetType().GetEvent("SettingChanged").AddEventHandler(enabledCfg, new EventHandler(ConfigChanged));
			}
			registeredPiece3.InitializeNewRegisteredPiece(registeredPiece3);
			[<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(2)]
			void ConfigChanged(object o, EventArgs e)
			{
				piecePrefab2.m_enabled = (int)enabledCfg.BoxedValue != 0;
			}
		}
		if (saveOnConfigSet)
		{
			plugin.Config.SaveOnConfigSet = true;
			plugin.Config.Save();
		}
		void ReloadConfigDisplay()
		{
			object obj = configManagerType?.GetProperty("DisplayingWindow").GetValue(configManager);
			if (obj is bool && (bool)obj)
			{
				configManagerType.GetMethod("BuildSettingList").Invoke(configManager, Array.Empty<object>());
			}
		}
	}

	private void InitializeNewRegisteredPiece(BuildPiece piece)
	{
		ConfigEntryBase recipeIsActive = piece.RecipeIsActive;
		PieceConfig cfg;
		Piece piecePrefab;
		string pieceName;
		if (recipeIsActive != null)
		{
			pieceConfigs.TryGetValue(piece, out cfg);
			piecePrefab = piece.Prefab.GetComponent<Piece>();
			pieceName = piecePrefab.m_name;
			recipeIsActive.GetType().GetEvent("SettingChanged").AddEventHandler(recipeIsActive, new EventHandler(ConfigChanged));
		}
		void ConfigChanged(object o, EventArgs e)
		{
			if ((bool)ObjectDB.instance && ObjectDB.instance.GetItemPrefab("YmirRemains") != null && cfg != null)
			{
				Piece.Requirement[] resources = SerializedRequirements.toPieceReqs(new SerializedRequirements(cfg.craft.Value));
				piecePrefab.m_resources = resources;
				Piece[] array = UnityEngine.Object.FindObjectsOfType<Piece>();
				foreach (Piece piece2 in array)
				{
					if (piece2.m_name == pieceName)
					{
						piece2.m_resources = resources;
					}
				}
			}
		}
	}

	[HarmonyPriority(700)]
	internal static void Patch_ObjectDBInit(ObjectDB __instance)
	{
		if (__instance.GetItemPrefab("YmirRemains") == null)
		{
			return;
		}
		foreach (BuildPiece registeredPiece in registeredPieces)
		{
			pieceConfigs.TryGetValue(registeredPiece, out var value);
			registeredPiece.Prefab.GetComponent<Piece>().m_resources = SerializedRequirements.toPieceReqs((value == null) ? new SerializedRequirements(registeredPiece.RequiredItems.Requirements) : new SerializedRequirements(value.craft.Value));
			foreach (ExtensionConfig extensionStation in registeredPiece.Extension.ExtensionStations)
			{
				switch ((value == null || registeredPiece.Extension.ExtensionStations.Count > 0) ? extensionStation.Table : value.extensionTable.Value)
				{
				case CraftingTable.None:
					registeredPiece.Prefab.GetComponent<StationExtension>().m_craftingStation = null;
					break;
				case CraftingTable.Custom:
				{
					GameObject prefab = ZNetScene.instance.GetPrefab((value == null || registeredPiece.Extension.ExtensionStations.Count > 0) ? extensionStation.custom : value.customExtentionTable.Value);
					if ((object)prefab != null)
					{
						registeredPiece.Prefab.GetComponent<StationExtension>().m_craftingStation = prefab.GetComponent<CraftingStation>();
					}
					else
					{
						Debug.LogWarning("Custom crafting station '" + ((value == null || registeredPiece.Extension.ExtensionStations.Count > 0) ? extensionStation.custom : value.customExtentionTable.Value) + "' does not exist");
					}
					break;
				}
				default:
					if (value != null && value.table.Value == CraftingTable.None)
					{
						registeredPiece.Prefab.GetComponent<StationExtension>().m_craftingStation = null;
					}
					else
					{
						registeredPiece.Prefab.GetComponent<StationExtension>().m_craftingStation = ZNetScene.instance.GetPrefab(((InternalName)typeof(CraftingTable).GetMember(((value == null || registeredPiece.Extension.ExtensionStations.Count > 0) ? extensionStation.Table : value.extensionTable.Value).ToString())[0].GetCustomAttributes(typeof(InternalName)).First()).internalName).GetComponent<CraftingStation>();
					}
					break;
				}
			}
			foreach (CraftingStationConfig station in registeredPiece.Crafting.Stations)
			{
				switch ((value == null || registeredPiece.Crafting.Stations.Count > 0) ? station.Table : value.table.Value)
				{
				case CraftingTable.None:
					registeredPiece.Prefab.GetComponent<Piece>().m_craftingStation = null;
					break;
				case CraftingTable.Custom:
				{
					GameObject prefab2 = ZNetScene.instance.GetPrefab((value == null || registeredPiece.Crafting.Stations.Count > 0) ? station.custom : value.customTable.Value);
					if ((object)prefab2 != null)
					{
						registeredPiece.Prefab.GetComponent<Piece>().m_craftingStation = prefab2.GetComponent<CraftingStation>();
					}
					else
					{
						Debug.LogWarning("Custom crafting station '" + ((value == null || registeredPiece.Crafting.Stations.Count > 0) ? station.custom : value.customTable.Value) + "' does not exist");
					}
					break;
				}
				default:
					if (value != null && value.table.Value == CraftingTable.None)
					{
						registeredPiece.Prefab.GetComponent<Piece>().m_craftingStation = null;
					}
					else
					{
						registeredPiece.Prefab.GetComponent<Piece>().m_craftingStation = ZNetScene.instance.GetPrefab(((InternalName)typeof(CraftingTable).GetMember(((value == null || registeredPiece.Crafting.Stations.Count > 0) ? station.Table : value.table.Value).ToString())[0].GetCustomAttributes(typeof(InternalName)).First()).internalName).GetComponent<CraftingStation>();
					}
					break;
				}
			}
			registeredPiece.conversions = new List<Smelter.ItemConversion>();
			for (int i = 0; i < registeredPiece.Conversions.Count; i++)
			{
				Conversion conversion = registeredPiece.Conversions[i];
				registeredPiece.conversions.Add(new Smelter.ItemConversion
				{
					m_from = SerializedRequirements.fetchByName(ObjectDB.instance, conversion.config?.input.Value ?? conversion.Input),
					m_to = SerializedRequirements.fetchByName(ObjectDB.instance, conversion.config?.output.Value ?? conversion.Output)
				});
				if ((object)registeredPiece.conversions[i].m_from != null && (object)registeredPiece.conversions[i].m_to != null)
				{
					registeredPiece.Prefab.GetComponent<Smelter>().m_conversion.Add(registeredPiece.conversions[i]);
				}
			}
		}
	}

	public void Snapshot(float lightIntensity = 1.3f, Quaternion? cameraRotation = null)
	{
		SnapshotPiece(Prefab, lightIntensity, cameraRotation);
	}

	internal void SnapshotPiece(GameObject prefab, float lightIntensity = 1.3f, Quaternion? cameraRotation = null)
	{
		if (!(prefab == null) && (prefab.GetComponentsInChildren<Renderer>().Any() || prefab.GetComponentsInChildren<MeshFilter>().Any()))
		{
			Camera component = new GameObject("CameraIcon", typeof(Camera)).GetComponent<Camera>();
			component.backgroundColor = Color.clear;
			component.clearFlags = CameraClearFlags.Color;
			component.transform.position = new Vector3(10000f, 10000f, 10000f);
			component.transform.rotation = cameraRotation ?? Quaternion.Euler(0f, 180f, 0f);
			component.fieldOfView = 0.5f;
			component.farClipPlane = 100000f;
			component.cullingMask = 8;
			Light component2 = new GameObject("LightIcon", typeof(Light)).GetComponent<Light>();
			component2.transform.position = new Vector3(10000f, 10000f, 10000f);
			component2.transform.rotation = Quaternion.Euler(5f, 180f, 5f);
			component2.type = LightType.Directional;
			component2.cullingMask = 8;
			component2.intensity = lightIntensity;
			GameObject gameObject = UnityEngine.Object.Instantiate(prefab);
			Transform[] componentsInChildren = gameObject.GetComponentsInChildren<Transform>();
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				componentsInChildren[i].gameObject.layer = 3;
			}
			gameObject.transform.position = Vector3.zero;
			gameObject.transform.rotation = Quaternion.Euler(23f, 51f, 25.8f);
			gameObject.name = prefab.name;
			MeshRenderer[] componentsInChildren2 = gameObject.GetComponentsInChildren<MeshRenderer>();
			Vector3 vector = componentsInChildren2.Aggregate(Vector3.positiveInfinity, [<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(0)] (Vector3 cur, MeshRenderer renderer) => Vector3.Min(cur, renderer.bounds.min));
			Vector3 vector2 = componentsInChildren2.Aggregate(Vector3.negativeInfinity, [<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(0)] (Vector3 cur, MeshRenderer renderer) => Vector3.Max(cur, renderer.bounds.max));
			gameObject.transform.position = new Vector3(10000f, 10000f, 10000f) - (vector + vector2) / 2f;
			Vector3 vector3 = vector2 - vector;
			gameObject.AddComponent<TimedDestruction>().Trigger(1f);
			Rect rect = new Rect(0f, 0f, 128f, 128f);
			component.targetTexture = RenderTexture.GetTemporary((int)rect.width, (int)rect.height);
			component.fieldOfView = 20f;
			float z = (Mathf.Max(vector3.x, vector3.y) + 0.1f) / Mathf.Tan(component.fieldOfView * (MathF.PI / 180f)) * 1.1f;
			component.transform.position = new Vector3(10000f, 10000f, 10000f) + new Vector3(0f, 0f, z);
			component.Render();
			RenderTexture active = RenderTexture.active;
			RenderTexture.active = component.targetTexture;
			Texture2D texture2D = new Texture2D((int)rect.width, (int)rect.height, TextureFormat.RGBA32, mipChain: false);
			texture2D.ReadPixels(new Rect(0f, 0f, (int)rect.width, (int)rect.height), 0, 0);
			texture2D.Apply();
			RenderTexture.active = active;
			prefab.GetComponent<Piece>().m_icon = Sprite.Create(texture2D, new Rect(0f, 0f, (int)rect.width, (int)rect.height), Vector2.one / 2f);
			component2.gameObject.SetActive(value: false);
			component.targetTexture.Release();
			component.gameObject.SetActive(value: false);
			gameObject.SetActive(value: false);
			UnityEngine.Object.DestroyImmediate(gameObject);
			UnityEngine.Object.Destroy(component);
			UnityEngine.Object.Destroy(component2);
			UnityEngine.Object.Destroy(component.gameObject);
			UnityEngine.Object.Destroy(component2.gameObject);
		}
	}

	private static void DrawConfigTable(ConfigEntryBase cfg)
	{
		bool valueOrDefault = cfg.Description.Tags.Select([<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(0)] (object a) => (!(a.GetType().Name == "ConfigurationManagerAttributes")) ? ((bool?)null) : ((bool?)a.GetType().GetField("ReadOnly")?.GetValue(a))).FirstOrDefault((bool? v) => v.HasValue) == true;
		List<Requirement> list = new List<Requirement>();
		bool flag = false;
		int num = (int)(configManager?.GetType().GetProperty("RightColumnWidth", BindingFlags.Instance | BindingFlags.NonPublic).GetGetMethod(nonPublic: true)
			.Invoke(configManager, Array.Empty<object>()) ?? ((object)130));
		GUILayout.BeginVertical();
		foreach (Requirement req in new SerializedRequirements((string)cfg.BoxedValue).Reqs)
		{
			GUILayout.BeginHorizontal();
			int num2 = req.amount;
			if (int.TryParse(GUILayout.TextField(num2.ToString(), new GUIStyle(GUI.skin.textField)
			{
				fixedWidth = 40f
			}), out var result) && result != num2 && !valueOrDefault)
			{
				num2 = result;
				flag = true;
			}
			string text = GUILayout.TextField(req.itemName, new GUIStyle(GUI.skin.textField)
			{
				fixedWidth = num - 40 - 67 - 21 - 21 - 12
			});
			string text2 = (valueOrDefault ? req.itemName : text);
			flag = flag || text2 != req.itemName;
			bool flag2 = req.recover;
			if (GUILayout.Toggle(req.recover, "Recover", new GUIStyle(GUI.skin.toggle)
			{
				fixedWidth = 67f
			}) != req.recover)
			{
				flag2 = !flag2;
				flag = true;
			}
			if (GUILayout.Button("x", new GUIStyle(GUI.skin.button)
			{
				fixedWidth = 21f
			}) && !valueOrDefault)
			{
				flag = true;
			}
			else
			{
				list.Add(new Requirement
				{
					amount = num2,
					itemName = text2,
					recover = flag2
				});
			}
			if (GUILayout.Button("+", new GUIStyle(GUI.skin.button)
			{
				fixedWidth = 21f
			}) && !valueOrDefault)
			{
				flag = true;
				list.Add(new Requirement
				{
					amount = 1,
					itemName = "",
					recover = false
				});
			}
			GUILayout.EndHorizontal();
		}
		GUILayout.EndVertical();
		if (flag)
		{
			cfg.BoxedValue = new SerializedRequirements(list).ToString();
		}
	}

	private static ConfigEntry<T> config<[<130f0e86-0392-462a-ad1d-c07a91e49931>Nullable(2)] T>(string group, string name, T value, ConfigDescription description)
	{
		ConfigEntry<T> configEntry = plugin.Config.Bind(group, name, value, description);
		configSync?.GetType().GetMethod("AddConfigEntry").MakeGenericMethod(typeof(T))
			.Invoke(configSync, new object[1] { configEntry });
		return configEntry;
	}

	private static ConfigEntry<T> config<[<130f0e86-0392-462a-ad1d-c07a91e49931>Nullable(2)] T>(string group, string name, T value, string description)
	{
		return config(group, name, value, new ConfigDescription(description, null));
	}
}

}


// ---- MistrootTamer.dll :: PieceManager.GoExtensions ----
namespace PieceManager
{
internal static class GoExtensions
{
	[<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(1)]
	public static T GetOrAddComponent<[<130f0e86-0392-462a-ad1d-c07a91e49931>Nullable(0)] T>(this GameObject gameObject) where T : Component
	{
		return gameObject.GetComponent<T>() ?? gameObject.AddComponent<T>();
	}
}

}


// ---- MistrootTamer.dll :: PieceManager.LocalizeKey ----
namespace PieceManager
{
[PublicAPI]
[<130f0e86-0392-462a-ad1d-c07a91e49931>Nullable(0)]
[<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(1)]
internal class LocalizeKey
{
	private static readonly List<LocalizeKey> keys = new List<LocalizeKey>();

	public readonly string Key;

	public readonly Dictionary<string, string> Localizations = new Dictionary<string, string>();

	public LocalizeKey(string key)
	{
		Key = key.Replace("$", "");
		keys.Add(this);
	}

	public void Alias(string alias)
	{
		Localizations.Clear();
		if (!alias.Contains("$"))
		{
			alias = "$" + alias;
		}
		Localizations["alias"] = alias;
		Localization.instance.AddWord(Key, Localization.instance.Localize(alias));
	}

	public LocalizeKey English(string key)
	{
		return addForLang("English", key);
	}

	public LocalizeKey Swedish(string key)
	{
		return addForLang("Swedish", key);
	}

	public LocalizeKey French(string key)
	{
		return addForLang("French", key);
	}

	public LocalizeKey Italian(string key)
	{
		return addForLang("Italian", key);
	}

	public LocalizeKey German(string key)
	{
		return addForLang("German", key);
	}

	public LocalizeKey Spanish(string key)
	{
		return addForLang("Spanish", key);
	}

	public LocalizeKey Russian(string key)
	{
		return addForLang("Russian", key);
	}

	public LocalizeKey Romanian(string key)
	{
		return addForLang("Romanian", key);
	}

	public LocalizeKey Bulgarian(string key)
	{
		return addForLang("Bulgarian", key);
	}

	public LocalizeKey Macedonian(string key)
	{
		return addForLang("Macedonian", key);
	}

	public LocalizeKey Finnish(string key)
	{
		return addForLang("Finnish", key);
	}

	public LocalizeKey Danish(string key)
	{
		return addForLang("Danish", key);
	}

	public LocalizeKey Norwegian(string key)
	{
		return addForLang("Norwegian", key);
	}

	public LocalizeKey Icelandic(string key)
	{
		return addForLang("Icelandic", key);
	}

	public LocalizeKey Turkish(string key)
	{
		return addForLang("Turkish", key);
	}

	public LocalizeKey Lithuanian(string key)
	{
		return addForLang("Lithuanian", key);
	}

	public LocalizeKey Czech(string key)
	{
		return addForLang("Czech", key);
	}

	public LocalizeKey Hungarian(string key)
	{
		return addForLang("Hungarian", key);
	}

	public LocalizeKey Slovak(string key)
	{
		return addForLang("Slovak", key);
	}

	public LocalizeKey Polish(string key)
	{
		return addForLang("Polish", key);
	}

	public LocalizeKey Dutch(string key)
	{
		return addForLang("Dutch", key);
	}

	public LocalizeKey Portuguese_European(string key)
	{
		return addForLang("Portuguese_European", key);
	}

	public LocalizeKey Portuguese_Brazilian(string key)
	{
		return addForLang("Portuguese_Brazilian", key);
	}

	public LocalizeKey Chinese(string key)
	{
		return addForLang("Chinese", key);
	}

	public LocalizeKey Japanese(string key)
	{
		return addForLang("Japanese", key);
	}

	public LocalizeKey Korean(string key)
	{
		return addForLang("Korean", key);
	}

	public LocalizeKey Hindi(string key)
	{
		return addForLang("Hindi", key);
	}

	public LocalizeKey Thai(string key)
	{
		return addForLang("Thai", key);
	}

	public LocalizeKey Abenaki(string key)
	{
		return addForLang("Abenaki", key);
	}

	public LocalizeKey Croatian(string key)
	{
		return addForLang("Croatian", key);
	}

	public LocalizeKey Georgian(string key)
	{
		return addForLang("Georgian", key);
	}

	public LocalizeKey Greek(string key)
	{
		return addForLang("Greek", key);
	}

	public LocalizeKey Serbian(string key)
	{
		return addForLang("Serbian", key);
	}

	public LocalizeKey Ukrainian(string key)
	{
		return addForLang("Ukrainian", key);
	}

	private LocalizeKey addForLang(string lang, string value)
	{
		Localizations[lang] = value;
		if (Localization.instance.GetSelectedLanguage() == lang)
		{
			Localization.instance.AddWord(Key, value);
		}
		else if (lang == "English" && !Localization.instance.m_translations.ContainsKey(Key))
		{
			Localization.instance.AddWord(Key, value);
		}
		return this;
	}

	[HarmonyPriority(300)]
	internal static void AddLocalizedKeys(Localization __instance, string language)
	{
		foreach (LocalizeKey key in keys)
		{
			string value2;
			if (key.Localizations.TryGetValue(language, out var value) || key.Localizations.TryGetValue("English", out value))
			{
				__instance.AddWord(key.Key, value);
			}
			else if (key.Localizations.TryGetValue("alias", out value2))
			{
				__instance.AddWord(key.Key, Localization.instance.Localize(value2));
			}
		}
	}
}

}


// ---- MistrootTamer.dll :: PieceManager.LocalizationCache ----
namespace PieceManager
{
[<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(1)]
[<130f0e86-0392-462a-ad1d-c07a91e49931>Nullable(0)]
internal static class LocalizationCache
{
	private static readonly Dictionary<string, Localization> localizations = new Dictionary<string, Localization>();

	internal static void LocalizationPostfix(Localization __instance, string language)
	{
		string key = localizations.FirstOrDefault([<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(0)] (KeyValuePair<string, Localization> l) => l.Value == __instance).Key;
		if (key != null)
		{
			localizations.Remove(key);
		}
		if (!localizations.ContainsKey(language))
		{
			localizations.Add(language, __instance);
		}
	}

	public static Localization ForLanguage([<130f0e86-0392-462a-ad1d-c07a91e49931>Nullable(2)] string language = null)
	{
		if (localizations.TryGetValue(language ?? PlayerPrefs.GetString("language", "English"), out var value))
		{
			return value;
		}
		value = new Localization();
		if (language != null)
		{
			value.SetupLanguage(language);
		}
		return value;
	}
}

}


// ---- MistrootTamer.dll :: PieceManager.AdminSyncing ----
namespace PieceManager
{
[<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(1)]
[<130f0e86-0392-462a-ad1d-c07a91e49931>Nullable(0)]
internal class AdminSyncing
{
	private static bool isServer;

	internal static bool registeredOnClient;

	[HarmonyPriority(700)]
	internal static void AdminStatusSync(ZNet __instance)
	{
		isServer = __instance.IsServer();
		if ((object)BuildPiece._plugin != null)
		{
			if (isServer)
			{
				ZRoutedRpc.instance.Register<ZPackage>(BuildPiece._plugin.Info.Metadata.Name + " PMAdminStatusSync", RPC_AdminPieceAddRemove);
			}
			else if (!registeredOnClient)
			{
				ZRoutedRpc.instance.Register<ZPackage>(BuildPiece._plugin.Info.Metadata.Name + " PMAdminStatusSync", RPC_AdminPieceAddRemove);
				registeredOnClient = true;
			}
		}
		if (isServer)
		{
			ZNet.instance.StartCoroutine(WatchAdminListChanges());
		}
		static void SendAdmin(List<ZNetPeer> peers, bool isAdmin)
		{
			ZPackage zPackage = new ZPackage();
			zPackage.Write(isAdmin);
			ZNet.instance.StartCoroutine(sendZPackage(peers, zPackage));
		}
		static IEnumerator WatchAdminListChanges()
		{
			List<string> currentList = new List<string>(ZNet.instance.m_adminList.GetList());
			while (true)
			{
				yield return new WaitForSeconds(30f);
				if (!ZNet.instance.m_adminList.GetList().SequenceEqual(currentList))
				{
					currentList = new List<string>(ZNet.instance.m_adminList.GetList());
					List<ZNetPeer> list = (from p in ZNet.instance.GetPeers()
						where ZNet.instance.ListContainsId(ZNet.instance.m_adminList, p.m_rpc.GetSocket().GetHostName())
						select p).ToList();
					SendAdmin(ZNet.instance.GetPeers().Except(list).ToList(), isAdmin: false);
					SendAdmin(list, isAdmin: true);
				}
			}
		}
	}

	private static IEnumerator sendZPackage(List<ZNetPeer> peers, ZPackage package)
	{
		if (!ZNet.instance)
		{
			yield break;
		}
		byte[] array = package.GetArray();
		if (array != null && array.LongLength > 10000)
		{
			ZPackage zPackage = new ZPackage();
			zPackage.Write(4);
			MemoryStream memoryStream = new MemoryStream();
			using (DeflateStream deflateStream = new DeflateStream(memoryStream, System.IO.Compression.CompressionLevel.Optimal))
			{
				deflateStream.Write(array, 0, array.Length);
			}
			zPackage.Write(memoryStream.ToArray());
			package = zPackage;
		}
		List<IEnumerator<bool>> writers = (from p in peers
			where p.IsReady()
			select TellPeerAdminStatus(p, package)).ToList();
		writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
		while (writers.Count > 0)
		{
			yield return null;
			writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
		}
	}

	private static IEnumerator<bool> TellPeerAdminStatus(ZNetPeer peer, ZPackage package)
	{
		ZRoutedRpc rpc = ZRoutedRpc.instance;
		if (rpc != null)
		{
			SendPackage(package);
		}
		void SendPackage(ZPackage pkg)
		{
			string text = BuildPiece._plugin?.Info.Metadata.Name + " PMAdminStatusSync";
			if (isServer)
			{
				peer.m_rpc.Invoke(text, pkg);
			}
			else
			{
				rpc.InvokeRoutedRPC(peer.m_server ? 0 : peer.m_uid, text, pkg);
			}
		}
		yield break;
	}

	internal static void RPC_AdminPieceAddRemove(long sender, ZPackage package)
	{
		ZNetPeer peer = ZNet.instance.GetPeer(sender);
		bool flag = false;
		try
		{
			flag = package.ReadBool();
		}
		catch
		{
		}
		if (isServer)
		{
			ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, BuildPiece._plugin?.Info.Metadata.Name + " PMAdminStatusSync", new ZPackage());
			if (ZNet.instance.ListContainsId(ZNet.instance.m_adminList, peer.m_rpc.GetSocket().GetHostName()))
			{
				ZPackage zPackage = new ZPackage();
				zPackage.Write(data: true);
				peer.m_rpc.Invoke(BuildPiece._plugin?.Info.Metadata.Name + " PMAdminStatusSync", zPackage);
			}
			return;
		}
		foreach (BuildPiece registeredPiece in BuildPiece.registeredPieces)
		{
			if (!registeredPiece.SpecialProperties.AdminOnly)
			{
				continue;
			}
			Piece component = registeredPiece.Prefab.GetComponent<Piece>();
			string name = component.m_name;
			Localization.instance.Localize(name).Trim();
			if (!ObjectDB.instance || ObjectDB.instance.GetItemPrefab("YmirRemains") == null)
			{
				continue;
			}
			Piece[] array = Object.FindObjectsOfType<Piece>();
			foreach (Piece piece in array)
			{
				if (flag)
				{
					if (piece.m_name == name)
					{
						piece.m_enabled = true;
					}
				}
				else if (piece.m_name == name)
				{
					piece.m_enabled = false;
				}
			}
			List<GameObject> pieces = ObjectDB.instance.GetItemPrefab("Hammer").GetComponent<ItemDrop>().m_itemData.m_shared.m_buildPieces.m_pieces;
			if (flag)
			{
				if (!pieces.Contains(ZNetScene.instance.GetPrefab(component.name)))
				{
					pieces.Add(ZNetScene.instance.GetPrefab(component.name));
				}
			}
			else if (pieces.Contains(ZNetScene.instance.GetPrefab(component.name)))
			{
				pieces.Remove(ZNetScene.instance.GetPrefab(component.name));
			}
		}
	}
}

}


// ---- MistrootTamer.dll :: PieceManager.RegisterClientRPCPatch ----
namespace PieceManager
{
[<130f0e86-0392-462a-ad1d-c07a91e49931>Nullable(0)]
[<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(1)]
[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
internal class RegisterClientRPCPatch
{
	private static void Postfix(ZNet __instance, ZNetPeer peer)
	{
		if (!__instance.IsServer())
		{
			peer.m_rpc.Register<ZPackage>(BuildPiece._plugin?.Info.Metadata.Name + " PMAdminStatusSync", RPC_InitialAdminSync);
			return;
		}
		ZPackage zPackage = new ZPackage();
		zPackage.Write(__instance.ListContainsId(__instance.m_adminList, peer.m_rpc.GetSocket().GetHostName()));
		peer.m_rpc.Invoke(BuildPiece._plugin?.Info.Metadata.Name + " PMAdminStatusSync", zPackage);
	}

	private static void RPC_InitialAdminSync(ZRpc rpc, ZPackage package)
	{
		AdminSyncing.RPC_AdminPieceAddRemove(0L, package);
	}
}

}


// ---- MistrootTamer.dll :: PieceManager.PiecePrefabManager ----
namespace PieceManager
{
[<130f0e86-0392-462a-ad1d-c07a91e49931>Nullable(0)]
[<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(1)]
internal static class PiecePrefabManager
{
	[<130f0e86-0392-462a-ad1d-c07a91e49931>Nullable(0)]
	private struct BundleId
	{
		[UsedImplicitly]
		public string assetBundleFileName;

		[UsedImplicitly]
		public string folderName;
	}

	private static readonly Dictionary<BundleId, AssetBundle> bundleCache;

	private static readonly List<GameObject> piecePrefabs;

	private static readonly Dictionary<string, Piece.PieceCategory> PieceCategories;

	private static readonly Dictionary<string, Piece.PieceCategory> OtherPieceCategories;

	private static readonly Dictionary<Piece.PieceCategory, string> VanillaLabels;

	internal static bool CategoryRefreshNeeded;

	static PiecePrefabManager()
	{
		bundleCache = new Dictionary<BundleId, AssetBundle>();
		piecePrefabs = new List<GameObject>();
		PieceCategories = new Dictionary<string, Piece.PieceCategory>();
		OtherPieceCategories = new Dictionary<string, Piece.PieceCategory>();
		VanillaLabels = new Dictionary<Piece.PieceCategory, string>();
		Harmony harmony = new Harmony("org.bepinex.helpers.PieceManager");
		harmony.Patch(AccessTools.DeclaredMethod(typeof(FejdStartup), "Awake"), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(BuildPiece), "Patch_FejdStartup")));
		harmony.Patch(AccessTools.DeclaredMethod(typeof(Localization), "LoadCSV"), null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(LocalizeKey), "AddLocalizedKeys")));
		harmony.Patch(AccessTools.DeclaredMethod(typeof(Localization), "SetupLanguage"), null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(LocalizationCache), "LocalizationPostfix")));
		harmony.Patch(AccessTools.DeclaredMethod(typeof(ObjectDB), "Awake"), null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "Patch_ObjectDBInit")));
		harmony.Patch(AccessTools.DeclaredMethod(typeof(ObjectDB), "Awake"), null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(BuildPiece), "Patch_ObjectDBInit")));
		harmony.Patch(AccessTools.DeclaredMethod(typeof(ObjectDB), "CopyOtherDB"), null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "Patch_ObjectDBInit")));
		harmony.Patch(AccessTools.DeclaredMethod(typeof(ZNet), "Awake"), null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(AdminSyncing), "AdminStatusSync")));
		harmony.Patch(AccessTools.DeclaredMethod(typeof(ZNetScene), "Awake"), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "Patch_ZNetSceneAwake")));
		harmony.Patch(AccessTools.DeclaredMethod(typeof(ZNetScene), "Awake"), null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "RefFixPatch_ZNetSceneAwake")));
		harmony.Patch(AccessTools.DeclaredMethod(typeof(PieceTable), "UpdateAvailable"), null, null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "UpdateAvailable_Transpiler")));
		harmony.Patch(AccessTools.DeclaredMethod(typeof(PieceTable), "UpdateAvailable"), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "UpdateAvailable_Prefix")), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "UpdateAvailable_Postfix")));
		harmony.Patch(AccessTools.DeclaredMethod(typeof(Player), "SetPlaceMode"), null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "Patch_SetPlaceMode")));
		harmony.Patch(AccessTools.DeclaredMethod(typeof(Hud), "Awake"), null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "Hud_AwakeCreateTabs")));
		harmony.Patch(AccessTools.DeclaredMethod(typeof(Hud), "UpdateBuild"), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "RepositionCatsIfNeeded")));
		harmony.Patch(AccessTools.DeclaredMethod(typeof(Hud), "LateUpdate"), null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "RepositionCatsIfNeeded")));
		harmony.Patch(AccessTools.DeclaredMethod(typeof(Enum), "GetValues"), null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "EnumGetValuesPatch")));
		harmony.Patch(AccessTools.DeclaredMethod(typeof(Enum), "GetNames"), null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "EnumGetNamesPatch")));
	}

	public static AssetBundle RegisterAssetBundle(string assetBundleFileName, string folderName = "assets")
	{
		BundleId key = new BundleId
		{
			assetBundleFileName = assetBundleFileName,
			folderName = folderName
		};
		if (!bundleCache.TryGetValue(key, out var value))
		{
			Dictionary<BundleId, AssetBundle> dictionary = bundleCache;
			AssetBundle obj = Resources.FindObjectsOfTypeAll<AssetBundle>().FirstOrDefault([<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(0)] (AssetBundle a) => a.name == assetBundleFileName) ?? AssetBundle.LoadFromStream(Assembly.GetExecutingAssembly().GetManifestResourceStream(Assembly.GetExecutingAssembly().GetName().Name + "." + folderName + "." + assetBundleFileName));
			AssetBundle result = obj;
			dictionary[key] = obj;
			return result;
		}
		return value;
	}

	public static IEnumerable<GameObject> FixRefs(AssetBundle assetBundle)
	{
		return assetBundle.LoadAllAssets<GameObject>();
	}

	public static GameObject RegisterPrefab(string assetBundleFileName, string prefabName, string folderName = "assets")
	{
		return RegisterPrefab(RegisterAssetBundle(assetBundleFileName, folderName), prefabName);
	}

	public static GameObject RegisterPrefab(AssetBundle assets, string prefabName)
	{
		if (assets == null)
		{
			Debug.LogError("Failed to load asset bundle. Please make sure to mark all asset bundles as embedded resources.");
			return null;
		}
		GameObject gameObject = assets.LoadAsset<GameObject>(prefabName);
		if (gameObject == null)
		{
			Debug.LogError("Failed to load prefab " + prefabName + " from asset bundle " + assets.name);
			return null;
		}
		piecePrefabs.Add(gameObject);
		return gameObject;
	}

	public static Sprite RegisterSprite(string assetBundleFileName, string prefabName, string folderName = "assets")
	{
		return RegisterSprite(RegisterAssetBundle(assetBundleFileName, folderName), prefabName);
	}

	public static Sprite RegisterSprite(AssetBundle assets, string prefabName)
	{
		return assets.LoadAsset<Sprite>(prefabName);
	}

	private static void EnumGetValuesPatch(Type enumType, ref Array __result)
	{
		if (!(enumType != typeof(Piece.PieceCategory)) && PieceCategories.Count != 0)
		{
			Piece.PieceCategory[] array = new Piece.PieceCategory[__result.Length + PieceCategories.Count];
			__result.CopyTo(array, 0);
			PieceCategories.Values.CopyTo(array, __result.Length);
			__result = array;
		}
	}

	private static void EnumGetNamesPatch(Type enumType, ref string[] __result)
	{
		if (!(enumType != typeof(Piece.PieceCategory)) && PieceCategories.Count != 0)
		{
			__result = __result.AddRangeToArray(PieceCategories.Keys.ToArray());
		}
	}

	public static Dictionary<Piece.PieceCategory, string> GetPieceCategoriesMap()
	{
		Array values = Enum.GetValues(typeof(Piece.PieceCategory));
		string[] names = Enum.GetNames(typeof(Piece.PieceCategory));
		Dictionary<Piece.PieceCategory, string> dictionary = new Dictionary<Piece.PieceCategory, string>();
		for (int i = 0; i < values.Length; i++)
		{
			dictionary[(Piece.PieceCategory)values.GetValue(i)] = names[i];
		}
		return dictionary;
	}

	public static Piece.PieceCategory GetCategory(string name)
	{
		if (Enum.TryParse<Piece.PieceCategory>(name, ignoreCase: true, out var result))
		{
			return result;
		}
		if (PieceCategories.TryGetValue(name, out result))
		{
			return result;
		}
		if (OtherPieceCategories.TryGetValue(name, out result))
		{
			return result;
		}
		Dictionary<Piece.PieceCategory, string> pieceCategoriesMap = GetPieceCategoriesMap();
		foreach (KeyValuePair<Piece.PieceCategory, string> item in pieceCategoriesMap)
		{
			if (item.Value == name)
			{
				result = item.Key;
				OtherPieceCategories[name] = result;
				return result;
			}
		}
		result = (Piece.PieceCategory)(pieceCategoriesMap.Count - 1);
		PieceCategories[name] = result;
		string categoryToken = GetCategoryToken(name);
		Localization.instance.AddWord(categoryToken, name);
		return result;
	}

	internal static void CreateCategoryTabs()
	{
		if ((bool)Hud.instance)
		{
			int num = ModifiedMaxCategory();
			for (int i = Hud.instance.m_pieceCategoryTabs.Length; i < num; i++)
			{
				GameObject item = CreateCategoryTab();
				Hud.instance.m_pieceCategoryTabs = Hud.instance.m_pieceCategoryTabs.AddItem(item).ToArray();
			}
			if ((bool)Player.m_localPlayer && (bool)Player.m_localPlayer.m_buildPieces)
			{
				RepositionCategories(Player.m_localPlayer.m_buildPieces);
				Player.m_localPlayer.UpdateAvailablePiecesList();
			}
		}
	}

	private static GameObject CreateCategoryTab()
	{
		GameObject gameObject = Hud.instance.m_pieceCategoryTabs[0];
		GameObject gameObject2 = UnityEngine.Object.Instantiate(Hud.instance.m_pieceCategoryTabs[0], gameObject.transform.parent);
		gameObject2.SetActive(value: false);
		UIInputHandler orAddComponent = gameObject2.GetOrAddComponent<UIInputHandler>();
		orAddComponent.m_onLeftDown = (Action<UIInputHandler>)Delegate.Combine(orAddComponent.m_onLeftDown, new Action<UIInputHandler>(Hud.instance.OnLeftClickCategory));
		TMP_Text[] componentsInChildren = gameObject2.GetComponentsInChildren<TMP_Text>();
		foreach (TMP_Text obj in componentsInChildren)
		{
			obj.rectTransform.offsetMin = new Vector2(3f, 1f);
			obj.rectTransform.offsetMax = new Vector2(-3f, -1f);
			obj.enableAutoSizing = true;
			obj.fontSizeMin = 12f;
			obj.fontSizeMax = 20f;
			obj.lineSpacing = 0.8f;
			obj.textWrappingMode = TextWrappingModes.Normal;
			obj.overflowMode = TextOverflowModes.Truncate;
		}
		return gameObject2;
	}

	private static int ModifiedMaxCategory()
	{
		return Enum.GetValues(typeof(Piece.PieceCategory)).Length - 1;
	}

	private static int GetMaxCategoryOrDefault()
	{
		try
		{
			return (int)Enum.Parse(typeof(Piece.PieceCategory), "Max");
		}
		catch (ArgumentException)
		{
			Debug.LogWarning("Could not find Piece.PieceCategory.Max, using fallback value 4");
			return 4;
		}
	}

	private static List<CodeInstruction> TranspileMaxCategory(IEnumerable<CodeInstruction> instructions, int maxOffset)
	{
		int num = GetMaxCategoryOrDefault() + maxOffset;
		List<CodeInstruction> list = new List<CodeInstruction>();
		foreach (CodeInstruction instruction in instructions)
		{
			if (instruction.LoadsConstant(num))
			{
				list.Add(new CodeInstruction(OpCodes.Call, AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "ModifiedMaxCategory")));
				if (maxOffset != 0)
				{
					list.Add(new CodeInstruction(OpCodes.Ldc_I4, maxOffset));
					list.Add(new CodeInstruction(OpCodes.Add));
				}
			}
			else
			{
				list.Add(instruction);
			}
		}
		return list;
	}

	private static IEnumerable<CodeInstruction> UpdateAvailable_Transpiler(IEnumerable<CodeInstruction> instructions)
	{
		return TranspileMaxCategory(instructions, 0);
	}

	private static HashSet<Piece.PieceCategory> CategoriesInPieceTable(PieceTable pieceTable)
	{
		HashSet<Piece.PieceCategory> hashSet = new HashSet<Piece.PieceCategory>();
		foreach (GameObject item in pieceTable.m_pieces.Where([<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(0)] (GameObject pieceFab) => pieceFab != null))
		{
			if (item.TryGetComponent<Piece>(out var component))
			{
				hashSet.Add(component.m_category);
			}
		}
		return hashSet;
	}

	private static void RepositionCatsIfNeeded()
	{
		if (CategoryRefreshNeeded)
		{
			CategoryRefreshNeeded = false;
			CreateCategoryTabs();
			RepositionCats();
		}
	}

	private static void RepositionCats()
	{
		if ((bool)Player.m_localPlayer && (bool)Player.m_localPlayer.m_buildPieces)
		{
			RepositionCategories(Player.m_localPlayer.m_buildPieces);
		}
	}

	private static void RepositionCategories(PieceTable pieceTable)
	{
		RectTransform rectTransform = (RectTransform)Hud.instance.m_pieceCategoryTabs[0].transform;
		RectTransform obj = (RectTransform)Hud.instance.m_pieceCategoryRoot.transform;
		RectTransform rectTransform2 = (RectTransform)Hud.instance.m_pieceSelectionWindow.transform;
		if (rectTransform.parent.TryGetComponent<HorizontalLayoutGroup>(out var component))
		{
			UnityEngine.Object.DestroyImmediate(component);
		}
		Vector2 size = rectTransform.rect.size;
		GridLayoutGroup component2;
		GridLayoutGroup obj2 = (rectTransform.parent.TryGetComponent<GridLayoutGroup>(out component2) ? component2 : rectTransform.parent.gameObject.AddComponent<GridLayoutGroup>());
		obj2.cellSize = size;
		obj2.spacing = new Vector2(0f, 1f);
		obj2.constraint = GridLayoutGroup.Constraint.FixedColumnCount;
		obj2.constraintCount = 5;
		obj2.childAlignment = TextAnchor.MiddleCenter;
		HashSet<Piece.PieceCategory> hashSet = CategoriesInPieceTable(pieceTable);
		UpdatePieceTableCategories(pieceTable, hashSet);
		int num = Mathf.Max((int)(obj.rect.width / size.x), 1);
		int count = pieceTable.m_categories.Count;
		float x = (0f - size.x) * (float)num / 2f + size.x / 2f;
		float y = (size.y + 1f) * Mathf.Floor((float)(count - 1) / (float)num) + 5f;
		new Vector2(x, y);
		int num2 = Mathf.CeilToInt((float)count / (float)num);
		float num3 = (size.y + 1f) * (float)num2;
		RectTransform component3 = rectTransform.parent.GetComponent<RectTransform>();
		component3.anchoredPosition = new Vector2(component3.anchoredPosition.x, num3 / 2f);
		int num4 = 0;
		for (int i = 0; i < Hud.instance.m_pieceCategoryTabs.Length; i++)
		{
			GameObject gameObject = Hud.instance.m_pieceCategoryTabs[i];
			if (gameObject == null)
			{
				continue;
			}
			if (i >= pieceTable.m_categories.Count)
			{
				gameObject.SetActive(value: false);
				continue;
			}
			Piece.PieceCategory item = pieceTable.m_categories[i];
			string text = pieceTable.m_categoryLabels[i];
			if (hashSet.Contains(item))
			{
				num4++;
			}
			gameObject.GetComponentInChildren<TMP_Text>().text = Localization.instance.Localize(text);
		}
		RectTransform rectTransform3 = (RectTransform)(rectTransform2.Find("Bkg2")?.transform);
		if ((bool)rectTransform3)
		{
			float y2 = (size.y + 1f) * (float)Mathf.Max(0, Mathf.FloorToInt((float)(num4 - 1) / (float)num));
			rectTransform3.offsetMax = new Vector2(rectTransform3.offsetMax.x, y2);
		}
		else
		{
			Debug.LogWarning("RefreshCategories: Could not find background image");
		}
		Hud.instance.GetComponentInParent<Localize>().RefreshLocalization();
	}

	private static void UpdatePieceTableCategories(PieceTable pieceTable, HashSet<Piece.PieceCategory> visibleCategories)
	{
		for (int i = 0; i < GetMaxCategoryOrDefault(); i++)
		{
			Piece.PieceCategory pieceCategory = (Piece.PieceCategory)i;
			if (visibleCategories.Contains(pieceCategory) && !pieceTable.m_categories.Contains(pieceCategory))
			{
				pieceTable.m_categories.Add(pieceCategory);
				pieceTable.m_categoryLabels.Add(GetVanillaLabel(pieceCategory));
			}
			if (!visibleCategories.Contains(pieceCategory) && pieceTable.m_categories.Contains(pieceCategory))
			{
				int index = pieceTable.m_categories.IndexOf(pieceCategory);
				pieceTable.m_categories.RemoveAt(index);
				pieceTable.m_categoryLabels.RemoveAt(index);
			}
		}
		foreach (KeyValuePair<string, Piece.PieceCategory> pieceCategory2 in PieceCategories)
		{
			string key = pieceCategory2.Key;
			Piece.PieceCategory value = pieceCategory2.Value;
			if (visibleCategories.Contains(value) && !pieceTable.m_categories.Contains(value))
			{
				pieceTable.m_categories.Add(value);
				pieceTable.m_categoryLabels.Add("$" + GetCategoryToken(key));
			}
			if (visibleCategories.Contains(value) && !pieceTable.m_categoryLabels.Contains("$" + GetCategoryToken(key)))
			{
				pieceTable.m_categoryLabels.Add("$" + GetCategoryToken(key));
			}
			if (!visibleCategories.Contains(value) && pieceTable.m_categories.Contains(value))
			{
				int index2 = pieceTable.m_categories.IndexOf(value);
				pieceTable.m_categories.RemoveAt(index2);
				pieceTable.m_categoryLabels.RemoveAt(index2);
			}
		}
	}

	private static string GetVanillaLabel(Piece.PieceCategory category)
	{
		if (!VanillaLabels.ContainsKey(category))
		{
			SearchVanillaLabels();
		}
		if (!VanillaLabels.TryGetValue(category, out var value))
		{
			return string.Empty;
		}
		return value;
	}

	private static void SearchVanillaLabels()
	{
		PieceTable[] array = Resources.FindObjectsOfTypeAll<PieceTable>();
		foreach (PieceTable pieceTable in array)
		{
			for (int j = 0; j < pieceTable.m_categories.Count; j++)
			{
				Piece.PieceCategory key = pieceTable.m_categories[j];
				if (j < pieceTable.m_categoryLabels.Count && !VanillaLabels.ContainsKey(key) && !string.IsNullOrEmpty(pieceTable.m_categoryLabels[j]))
				{
					VanillaLabels[key] = pieceTable.m_categoryLabels[j];
				}
			}
		}
	}

	private static string GetCategoryToken(string name)
	{
		char[] endChars = Localization.instance.m_endChars;
		string text = string.Concat(name.ToLower().Split(endChars));
		return "piecemanager_cat_" + text;
	}

	private static void Patch_SetPlaceMode(Player __instance)
	{
		if ((bool)__instance.m_buildPieces)
		{
			RepositionCategories(__instance.m_buildPieces);
		}
	}

	private static void UpdateAvailable_Prefix(PieceTable __instance)
	{
		if (__instance.m_availablePieces.Count > 0)
		{
			int num = ModifiedMaxCategory() - __instance.m_availablePieces.Count;
			for (int i = 0; i < num; i++)
			{
				__instance.m_availablePieces.Add(new List<Piece>());
			}
		}
	}

	private static void UpdateAvailable_Postfix(PieceTable __instance)
	{
		Array.Resize(ref __instance.m_selectedPiece, __instance.m_availablePieces.Count);
		Array.Resize(ref __instance.m_lastSelectedPiece, __instance.m_availablePieces.Count);
	}

	[HarmonyPriority(200)]
	private static void Hud_AwakeCreateTabs()
	{
		CreateCategoryTabs();
	}

	[HarmonyPriority(700)]
	private static void Patch_ZNetSceneAwake(ZNetScene __instance)
	{
		foreach (GameObject piecePrefab in piecePrefabs)
		{
			if (!__instance.m_prefabs.Contains(piecePrefab))
			{
				__instance.m_prefabs.Add(piecePrefab);
			}
		}
	}

	[HarmonyPriority(700)]
	private static void RefFixPatch_ZNetSceneAwake(ZNetScene __instance)
	{
		foreach (GameObject piecePrefab in piecePrefabs)
		{
			if (__instance.m_prefabs.Contains(piecePrefab) && (bool)piecePrefab.GetComponent<StationExtension>())
			{
				piecePrefab.GetComponent<Piece>().m_isUpgrade = true;
				piecePrefab.GetComponent<StationExtension>().m_connectionPrefab = __instance.GetPrefab("piece_workbench_ext3").GetComponent<StationExtension>().m_connectionPrefab;
				piecePrefab.GetComponent<StationExtension>().m_connectionOffset = __instance.GetPrefab("piece_workbench_ext3").GetComponent<StationExtension>().m_connectionOffset;
			}
		}
	}

	[HarmonyPriority(300)]
	private static void Patch_ObjectDBInit(ObjectDB __instance)
	{
		foreach (BuildPiece registeredPiece in BuildPiece.registeredPieces)
		{
			string[] activeTools = registeredPiece.activeTools;
			foreach (string name in activeTools)
			{
				PieceTable pieceTable = __instance.GetItemPrefab(name)?.GetComponent<ItemDrop>().m_itemData.m_shared.m_buildPieces;
				if ((object)pieceTable != null && !pieceTable.m_pieces.Contains(registeredPiece.Prefab))
				{
					pieceTable.m_pieces.Add(registeredPiece.Prefab);
				}
			}
		}
	}
}

}


// ---- MistrootTamer.dll :: PieceManager.Conversion ----
namespace PieceManager
{
[<130f0e86-0392-462a-ad1d-c07a91e49931>Nullable(0)]
[<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(1)]
[PublicAPI]
internal class Conversion
{
	[<130f0e86-0392-462a-ad1d-c07a91e49931>Nullable(0)]
	internal class ConversionConfig
	{
		public ConfigEntry<string> input;

		public ConfigEntry<string> output;
	}

	public string Input;

	public string Output;

	[<130f0e86-0392-462a-ad1d-c07a91e49931>Nullable(2)]
	internal ConversionConfig config;

	public Conversion(BuildPiece conversionPiece)
	{
		conversionPiece.Conversions.Add(this);
	}
}

}


// ---- MistrootTamer.dll :: PieceManager.SnapPoint ----
namespace PieceManager
{
[<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(1)]
[<130f0e86-0392-462a-ad1d-c07a91e49931>Nullable(0)]
internal class SnapPoint
{
	public GameObject GameObject { get; private set; }

	public bool IsInUse { get; set; }

	public SnapPoint(GameObject gameObject)
	{
		GameObject = gameObject;
	}
}

}


// ---- MistrootTamer.dll :: PieceManager.SnapPointMaker ----
namespace PieceManager
{
[PublicAPI]
[<130f0e86-0392-462a-ad1d-c07a91e49931>Nullable(0)]
[<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(1)]
internal class SnapPointMaker
{
	[<24ef9e07-b88d-43f2-861f-c2e042f741b0>NullableContext(0)]
	public enum SnapPointType
	{
		Vertices,
		Center,
		Poles,
		Equator
	}

	private static readonly List<GameObject> ObjectsToApplySnaps = new List<GameObject>();

	private static readonly List<SnapPoint> SnapPoints = new List<SnapPoint>();

	public static void AddObjectForSnapPoints(GameObject obj)
	{
		ObjectsToApplySnaps.Add(obj);
	}

	public static void ApplySnapPoints(SnapPointType snapPointType)
	{
		foreach (GameObject objectsToApplySnap in ObjectsToApplySnaps)
		{
			GrabVerticesAssignSnaps(objectsToApplySnap, snapPointType);
		}
	}

	private static void GrabVerticesAssignSnaps(GameObject obj, SnapPointType snapPointType)
	{
		Collider component = obj.GetComponent<Collider>();
		if (component is BoxCollider col)
		{
			Vector3[] boxColliderSnapPoints = GetBoxColliderSnapPoints(obj, col, snapPointType);
			AttachSnapPoints(obj, boxColliderSnapPoints);
		}
		else if (component is SphereCollider col2)
		{
			Vector3[] sphereColliderSnapPoints = GetSphereColliderSnapPoints(obj, col2, snapPointType);
			AttachSnapPoints(obj, sphereColliderSnapPoints);
		}
		else
		{
			Debug.LogWarning("Unsupported collider type for " + obj.name + ": " + component.GetType());
		}
	}

	private static Vector3[] GetBoxColliderSnapPoints(GameObject obj, BoxCollider col, SnapPointType snapPointType)
	{
		List<Vector3> list = new List<Vector3>();
		Transform transform = obj.transform;
		Vector3 vector = col.center - col.size * 0.5f;
		Vector3 vector2 = col.center + col.size * 0.5f;
		if (snapPointType == SnapPointType.Vertices || snapPointType == SnapPointType.Center)
		{
			list.Add(transform.TransformPoint(new Vector3(vector.x, vector.y, vector.z)));
			list.Add(transform.TransformPoint(new Vector3(vector.x, vector.y, vector2.z)));
			list.Add(transform.TransformPoint(new Vector3(vector.x, vector2.y, vector.z)));
			list.Add(transform.TransformPoint(new Vector3(vector.x, vector2.y, vector2.z)));
			list.Add(transform.TransformPoint(new Vector3(vector2.x, vector.y, vector.z)));
			list.Add(transform.TransformPoint(new Vector3(vector2.x, vector.y, vector2.z)));
			list.Add(transform.TransformPoint(new Vector3(vector2.x, vector2.y, vector.z)));
			list.Add(transform.TransformPoint(new Vector3(vector2.x, vector2.y, vector2.z)));
		}
		if (snapPointType == SnapPointType.Center)
		{
			list.Add(transform.TransformPoint(col.center));
		}
		return list.ToArray();
	}

	private static Vector3[] GetSphereColliderSnapPoints(GameObject obj, SphereCollider col, SnapPointType snapPointType)
	{
		List<Vector3> list = new List<Vector3>();
		Transform transform = obj.transform;
		if (snapPointType == SnapPointType.Poles || snapPointType == SnapPointType.Center)
		{
			list.Add(transform.TransformPoint(new Vector3(0f, col.radius, 0f)));
			list.Add(transform.TransformPoint(new Vector3(0f, 0f - col.radius, 0f)));
		}
		if (snapPointType == SnapPointType.Equator)
		{
			list.Add(transform.TransformPoint(new Vector3(0f - col.radius, 0f, 0f)));
			list.Add(transform.TransformPoint(new Vector3(col.radius, 0f, 0f)));
			list.Add(transform.TransformPoint(new Vector3(0f, 0f, 0f - col.radius)));
			list.Add(transform.TransformPoint(new Vector3(0f, 0f, col.radius)));
		}
		if (snapPointType == SnapPointType.Center)
		{
			list.Add(transform.TransformPoint(col.center));
		}
		return list.ToArray();
	}

	private static Vector3[] GetColliderVertexPosRotated(GameObject obj)
	{
		Vector3[] array = new Vector3[8];
		BoxCollider componentInChildren = obj.GetComponentInChildren<BoxCollider>();
		if (componentInChildren == null)
		{
			return array;
		}
		Transform transform = obj.transform;
		Vector3 vector = componentInChildren.center - componentInChildren.size * 0.5f;
		Vector3 vector2 = componentInChildren.center + componentInChildren.size * 0.5f;
		array[0] = transform.TransformPoint(new Vector3(vector.x, vector.y, vector.z));
		array[1] = transform.TransformPoint(new Vector3(vector.x, vector.y, vector2.z));
		array[2] = transform.TransformPoint(new Vector3(vector.x, vector2.y, vector.z));
		array[3] = transform.TransformPoint(new Vector3(vector.x, vector2.y, vector2.z));
		array[4] = transform.TransformPoint(new Vector3(vector2.x, vector.y, vector.z));
		array[5] = transform.TransformPoint(new Vector3(vector2.x, vector.y, vector2.z));
		array[6] = transform.TransformPoint(new Vector3(vector2.x, vector2.y, vector.z));
		array[7] = transform.TransformPoint(new Vector3(vector2.x, vector2.y, vector2.z));
		return array;
	}

	private static void AttachSnapPoints(GameObject objecttosnap, Vector3[] vector3S)
	{
		foreach (Vector3 position in vector3S)
		{
			AddSnapPoint(objecttosnap, position).GameObject.SetActive(value: false);
		}
	}

	public static SnapPoint AddSnapPoint(GameObject parent, Vector3 position)
	{
		foreach (SnapPoint snapPoint2 in SnapPoints)
		{
			if (!snapPoint2.IsInUse)
			{
				snapPoint2.GameObject.transform.SetParent(parent.transform, worldPositionStays: false);
				snapPoint2.GameObject.transform.position = position;
				snapPoint2.IsInUse = true;
				return snapPoint2;
			}
		}
		GameObject gameObject = new GameObject("_snappoint");
		gameObject.tag = "snappoint";
		gameObject.layer = 10;
		gameObject.transform.SetParent(parent.transform, worldPositionStays: false);
		gameObject.transform.position = position;
		SnapPoint snapPoint = new SnapPoint(gameObject);
		snapPoint.IsInUse = true;
		SnapPoints.Add(snapPoint);
		return snapPoint;
	}

	public static void ReleaseSnapPoint(SnapPoint snapPoint)
	{
		snapPoint.GameObject.transform.parent = null;
		snapPoint.IsInUse = false;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.CultureInfoAdapter ----
namespace YamlDotNet
{
internal sealed class CultureInfoAdapter : CultureInfo
{
	private readonly IFormatProvider provider;

	public CultureInfoAdapter(CultureInfo baseCulture, IFormatProvider provider)
		: base(baseCulture.LCID)
	{
		this.provider = provider;
	}

	public override object? GetFormat(Type? formatType)
	{
		return provider.GetFormat(formatType);
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.ReflectionExtensions ----
namespace YamlDotNet
{
internal static class ReflectionExtensions
{
	private static readonly FieldInfo? RemoteStackTraceField = typeof(Exception).GetField("_remoteStackTraceString", BindingFlags.Instance | BindingFlags.NonPublic);

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

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

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

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

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

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

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

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

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

	public static PropertyInfo? GetPublicProperty(this Type type, string name)
	{
		return type.GetProperty(name);
	}

	public static FieldInfo? GetPublicStaticField(this Type type, string name)
	{
		return type.GetField(name, BindingFlags.Static | BindingFlags.Public);
	}

	public static IEnumerable<PropertyInfo> GetProperties(this Type type, bool includeNonPublic)
	{
		BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public;
		if (includeNonPublic)
		{
			bindingFlags |= BindingFlags.NonPublic;
		}
		if (!type.IsInterface)
		{
			return type.GetProperties(bindingFlags);
		}
		return new Type[1] { type }.Concat(type.GetInterfaces()).SelectMany((Type i) => i.GetProperties(bindingFlags));
	}

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

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

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

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

	public static MethodInfo? GetPublicStaticMethod(this Type type, string name, params Type[] parameterTypes)
	{
		return type.GetMethod(name, BindingFlags.Static | BindingFlags.Public, null, parameterTypes, null);
	}

	public static MethodInfo? GetPublicInstanceMethod(this Type type, string name)
	{
		return type.GetMethod(name, BindingFlags.Instance | BindingFlags.Public);
	}

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

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

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

}


// ---- MistrootTamer.dll :: YamlDotNet.PropertyInfoExtensions ----
namespace YamlDotNet
{
internal static class PropertyInfoExtensions
{
	public static object? ReadValue(this PropertyInfo property, object target)
	{
		return property.GetValue(target, null);
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.StandardRegexOptions ----
namespace YamlDotNet
{
internal static class StandardRegexOptions
{
	public const RegexOptions Compiled = RegexOptions.Compiled;
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.BuilderSkeleton`1 ----
namespace YamlDotNet.Serialization
{
internal abstract class BuilderSkeleton<TBuilder> where TBuilder : BuilderSkeleton<TBuilder>
{
	internal INamingConvention namingConvention = NullNamingConvention.Instance;

	internal ITypeResolver typeResolver;

	internal readonly YamlAttributeOverrides overrides;

	internal readonly LazyComponentRegistrationList<Nothing, IYamlTypeConverter> typeConverterFactories;

	internal readonly LazyComponentRegistrationList<ITypeInspector, ITypeInspector> typeInspectorFactories;

	internal bool ignoreFields;

	internal bool includeNonPublicProperties;

	internal Settings settings;

	protected abstract TBuilder Self { get; }

	internal BuilderSkeleton(ITypeResolver typeResolver)
	{
		overrides = new YamlAttributeOverrides();
		typeConverterFactories = new LazyComponentRegistrationList<Nothing, IYamlTypeConverter>
		{
			{
				typeof(GuidConverter),
				(Nothing _) => new GuidConverter(jsonCompatible: false)
			},
			{
				typeof(SystemTypeConverter),
				(Nothing _) => new SystemTypeConverter()
			}
		};
		typeInspectorFactories = new LazyComponentRegistrationList<ITypeInspector, ITypeInspector>();
		this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
		settings = new Settings();
	}

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

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

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

	public TBuilder WithNamingConvention(INamingConvention namingConvention)
	{
		this.namingConvention = namingConvention ?? throw new ArgumentNullException("namingConvention");
		return Self;
	}

	public TBuilder WithTypeResolver(ITypeResolver typeResolver)
	{
		this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
		return Self;
	}

	public abstract TBuilder WithTagMapping(TagName tag, Type type);

	public TBuilder WithAttributeOverride<TClass>(Expression<Func<TClass, object>> propertyAccessor, Attribute attribute)
	{
		overrides.Add(propertyAccessor, attribute);
		return Self;
	}

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

	public TBuilder WithTypeConverter(IYamlTypeConverter typeConverter)
	{
		return WithTypeConverter(typeConverter, delegate(IRegistrationLocationSelectionSyntax<IYamlTypeConverter> w)
		{
			w.OnTop();
		});
	}

	public TBuilder WithTypeConverter(IYamlTypeConverter typeConverter, Action<IRegistrationLocationSelectionSyntax<IYamlTypeConverter>> where)
	{
		if (typeConverter == null)
		{
			throw new ArgumentNullException("typeConverter");
		}
		if (where == null)
		{
			throw new ArgumentNullException("where");
		}
		where(typeConverterFactories.CreateRegistrationLocationSelector(typeConverter.GetType(), (Nothing _) => typeConverter));
		return Self;
	}

	public TBuilder WithTypeConverter<TYamlTypeConverter>(WrapperFactory<IYamlTypeConverter, IYamlTypeConverter> typeConverterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IYamlTypeConverter>> where) where TYamlTypeConverter : IYamlTypeConverter
	{
		if (typeConverterFactory == null)
		{
			throw new ArgumentNullException("typeConverterFactory");
		}
		if (where == null)
		{
			throw new ArgumentNullException("where");
		}
		where(typeConverterFactories.CreateTrackingRegistrationLocationSelector(typeof(TYamlTypeConverter), (IYamlTypeConverter wrapped, Nothing _) => typeConverterFactory(wrapped)));
		return Self;
	}

	public TBuilder WithoutTypeConverter<TYamlTypeConverter>() where TYamlTypeConverter : IYamlTypeConverter
	{
		return WithoutTypeConverter(typeof(TYamlTypeConverter));
	}

	public TBuilder WithoutTypeConverter(Type converterType)
	{
		if (converterType == null)
		{
			throw new ArgumentNullException("converterType");
		}
		typeConverterFactories.Remove(converterType);
		return Self;
	}

	public TBuilder WithTypeInspector<TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory) where TTypeInspector : ITypeInspector
	{
		return WithTypeInspector(typeInspectorFactory, delegate(IRegistrationLocationSelectionSyntax<ITypeInspector> w)
		{
			w.OnTop();
		});
	}

	public TBuilder WithTypeInspector<TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory, Action<IRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
	{
		if (typeInspectorFactory == null)
		{
			throw new ArgumentNullException("typeInspectorFactory");
		}
		if (where == null)
		{
			throw new ArgumentNullException("where");
		}
		where(typeInspectorFactories.CreateRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector inner) => typeInspectorFactory(inner)));
		return Self;
	}

	public TBuilder WithTypeInspector<TTypeInspector>(WrapperFactory<ITypeInspector, ITypeInspector, TTypeInspector> typeInspectorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
	{
		if (typeInspectorFactory == null)
		{
			throw new ArgumentNullException("typeInspectorFactory");
		}
		if (where == null)
		{
			throw new ArgumentNullException("where");
		}
		where(typeInspectorFactories.CreateTrackingRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector wrapped, ITypeInspector inner) => typeInspectorFactory(wrapped, inner)));
		return Self;
	}

	public TBuilder WithoutTypeInspector<TTypeInspector>() where TTypeInspector : ITypeInspector
	{
		return WithoutTypeInspector(typeof(TTypeInspector));
	}

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

	protected IEnumerable<IYamlTypeConverter> BuildTypeConverters()
	{
		return typeConverterFactories.BuildComponentList();
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.WrapperFactory`2 ----
namespace YamlDotNet.Serialization
{
internal delegate TComponent WrapperFactory<TComponentBase, TComponent>(TComponentBase wrapped) where TComponent : TComponentBase;

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.WrapperFactory`3 ----
namespace YamlDotNet.Serialization
{
internal delegate TComponent WrapperFactory<TArgument, TComponentBase, TComponent>(TComponentBase wrapped, TArgument argument) where TComponent : TComponentBase;

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.DefaultValuesHandling ----
namespace YamlDotNet.Serialization
{
[Flags]
internal enum DefaultValuesHandling
{
	Preserve = 0,
	OmitNull = 1,
	OmitDefaults = 2,
	OmitEmptyCollections = 4
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.Deserializer ----
namespace YamlDotNet.Serialization
{
internal sealed class Deserializer : IDeserializer
{
	private readonly IValueDeserializer valueDeserializer;

	public Deserializer()
		: this(new DeserializerBuilder().BuildValueDeserializer())
	{
	}

	private Deserializer(IValueDeserializer valueDeserializer)
	{
		this.valueDeserializer = valueDeserializer ?? throw new ArgumentNullException("valueDeserializer");
	}

	public static Deserializer FromValueDeserializer(IValueDeserializer valueDeserializer)
	{
		return new Deserializer(valueDeserializer);
	}

	public T Deserialize<T>(string input)
	{
		using StringReader input2 = new StringReader(input);
		return Deserialize<T>(input2);
	}

	public T Deserialize<T>(TextReader input)
	{
		return Deserialize<T>(new Parser(input));
	}

	public T Deserialize<T>(IParser parser)
	{
		return (T)Deserialize(parser, typeof(T));
	}

	public object? Deserialize(string input)
	{
		return Deserialize(input, typeof(object));
	}

	public object? Deserialize(TextReader input)
	{
		return Deserialize(input, typeof(object));
	}

	public object? Deserialize(IParser parser)
	{
		return Deserialize(parser, typeof(object));
	}

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

	public object? Deserialize(TextReader input, Type type)
	{
		return Deserialize(new Parser(input), type);
	}

	public object? Deserialize(IParser parser, Type type)
	{
		if (parser == null)
		{
			throw new ArgumentNullException("parser");
		}
		if (type == null)
		{
			throw new ArgumentNullException("type");
		}
		StreamStart @event;
		bool flag = parser.TryConsume<StreamStart>(out @event);
		DocumentStart event2;
		bool flag2 = parser.TryConsume<DocumentStart>(out event2);
		object result = null;
		if (!parser.Accept<DocumentEnd>(out var _) && !parser.Accept<StreamEnd>(out var _))
		{
			using SerializerState serializerState = new SerializerState();
			result = valueDeserializer.DeserializeValue(parser, type, serializerState, valueDeserializer);
			serializerState.OnDeserialization();
		}
		if (flag2)
		{
			parser.Consume<DocumentEnd>();
		}
		if (flag)
		{
			parser.Consume<StreamEnd>();
		}
		return result;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.DeserializerBuilder ----
namespace YamlDotNet.Serialization
{
internal sealed class DeserializerBuilder : BuilderSkeleton<DeserializerBuilder>
{
	private Lazy<IObjectFactory> objectFactory;

	private readonly LazyComponentRegistrationList<Nothing, INodeDeserializer> nodeDeserializerFactories;

	private readonly LazyComponentRegistrationList<Nothing, INodeTypeResolver> nodeTypeResolverFactories;

	private readonly Dictionary<TagName, Type> tagMappings;

	private readonly Dictionary<Type, Type> typeMappings;

	private readonly ITypeConverter typeConverter;

	private bool ignoreUnmatched;

	private bool duplicateKeyChecking;

	private bool attemptUnknownTypeDeserialization;

	protected override DeserializerBuilder Self => this;

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

	internal ITypeInspector BuildTypeInspector()
	{
		ITypeInspector typeInspector = new WritablePropertiesTypeInspector(typeResolver, includeNonPublicProperties);
		if (!ignoreFields)
		{
			typeInspector = new CompositeTypeInspector(new ReadableFieldsTypeInspector(typeResolver), typeInspector);
		}
		return typeInspectorFactories.BuildComponentChain(typeInspector);
	}

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

	public DeserializerBuilder WithObjectFactory(IObjectFactory objectFactory)
	{
		if (objectFactory == null)
		{
			throw new ArgumentNullException("objectFactory");
		}
		this.objectFactory = new Lazy<IObjectFactory>(() => objectFactory, isThreadSafe: true);
		return this;
	}

	public DeserializerBuilder WithObjectFactory(Func<Type, object> objectFactory)
	{
		if (objectFactory == null)
		{
			throw new ArgumentNullException("objectFactory");
		}
		return WithObjectFactory(new LambdaObjectFactory(objectFactory));
	}

	public DeserializerBuilder WithNodeDeserializer(INodeDeserializer nodeDeserializer)
	{
		return WithNodeDeserializer(nodeDeserializer, delegate(IRegistrationLocationSelectionSyntax<INodeDeserializer> w)
		{
			w.OnTop();
		});
	}

	public DeserializerBuilder WithNodeDeserializer(INodeDeserializer nodeDeserializer, Action<IRegistrationLocationSelectionSyntax<INodeDeserializer>> where)
	{
		if (nodeDeserializer == null)
		{
			throw new ArgumentNullException("nodeDeserializer");
		}
		if (where == null)
		{
			throw new ArgumentNullException("where");
		}
		where(nodeDeserializerFactories.CreateRegistrationLocationSelector(nodeDeserializer.GetType(), (Nothing _) => nodeDeserializer));
		return this;
	}

	public DeserializerBuilder WithNodeDeserializer<TNodeDeserializer>(WrapperFactory<INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeDeserializer>> where) where TNodeDeserializer : INodeDeserializer
	{
		if (nodeDeserializerFactory == null)
		{
			throw new ArgumentNullException("nodeDeserializerFactory");
		}
		if (where == null)
		{
			throw new ArgumentNullException("where");
		}
		where(nodeDeserializerFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeDeserializer), (INodeDeserializer wrapped, Nothing _) => nodeDeserializerFactory(wrapped)));
		return this;
	}

	public DeserializerBuilder WithoutNodeDeserializer<TNodeDeserializer>() where TNodeDeserializer : INodeDeserializer
	{
		return WithoutNodeDeserializer(typeof(TNodeDeserializer));
	}

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

	public DeserializerBuilder WithTypeDiscriminatingNodeDeserializer(Action<ITypeDiscriminatingNodeDeserializerOptions> configureTypeDiscriminatingNodeDeserializerOptions, int maxDepth = -1, int maxLength = -1)
	{
		TypeDiscriminatingNodeDeserializerOptions typeDiscriminatingNodeDeserializerOptions = new TypeDiscriminatingNodeDeserializerOptions();
		configureTypeDiscriminatingNodeDeserializerOptions(typeDiscriminatingNodeDeserializerOptions);
		TypeDiscriminatingNodeDeserializer nodeDeserializer = new TypeDiscriminatingNodeDeserializer(nodeDeserializerFactories.BuildComponentList(), typeDiscriminatingNodeDeserializerOptions.discriminators, maxDepth, maxLength);
		return WithNodeDeserializer(nodeDeserializer, delegate(IRegistrationLocationSelectionSyntax<INodeDeserializer> s)
		{
			s.Before<DictionaryNodeDeserializer>();
		});
	}

	public DeserializerBuilder WithNodeTypeResolver(INodeTypeResolver nodeTypeResolver)
	{
		return WithNodeTypeResolver(nodeTypeResolver, delegate(IRegistrationLocationSelectionSyntax<INodeTypeResolver> w)
		{
			w.OnTop();
		});
	}

	public DeserializerBuilder WithNodeTypeResolver(INodeTypeResolver nodeTypeResolver, Action<IRegistrationLocationSelectionSyntax<INodeTypeResolver>> where)
	{
		if (nodeTypeResolver == null)
		{
			throw new ArgumentNullException("nodeTypeResolver");
		}
		if (where == null)
		{
			throw new ArgumentNullException("where");
		}
		where(nodeTypeResolverFactories.CreateRegistrationLocationSelector(nodeTypeResolver.GetType(), (Nothing _) => nodeTypeResolver));
		return this;
	}

	public DeserializerBuilder WithNodeTypeResolver<TNodeTypeResolver>(WrapperFactory<INodeTypeResolver, TNodeTypeResolver> nodeTypeResolverFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeTypeResolver>> where) where TNodeTypeResolver : INodeTypeResolver
	{
		if (nodeTypeResolverFactory == null)
		{
			throw new ArgumentNullException("nodeTypeResolverFactory");
		}
		if (where == null)
		{
			throw new ArgumentNullException("where");
		}
		where(nodeTypeResolverFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeTypeResolver), (INodeTypeResolver wrapped, Nothing _) => nodeTypeResolverFactory(wrapped)));
		return this;
	}

	public DeserializerBuilder WithoutNodeTypeResolver<TNodeTypeResolver>() where TNodeTypeResolver : INodeTypeResolver
	{
		return WithoutNodeTypeResolver(typeof(TNodeTypeResolver));
	}

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

	public override DeserializerBuilder WithTagMapping(TagName tag, Type type)
	{
		if (tag.IsEmpty)
		{
			throw new ArgumentException("Non-specific tags cannot be maped");
		}
		if (type == null)
		{
			throw new ArgumentNullException("type");
		}
		if (tagMappings.TryGetValue(tag, out Type value))
		{
			throw new ArgumentException($"Type already has a registered type '{value.FullName}' for tag '{tag}'", "tag");
		}
		tagMappings.Add(tag, type);
		return this;
	}

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

	public DeserializerBuilder WithoutTagMapping(TagName tag)
	{
		if (tag.IsEmpty)
		{
			throw new ArgumentException("Non-specific tags cannot be maped");
		}
		if (!tagMappings.Remove(tag))
		{
			throw new KeyNotFoundException($"Tag '{tag}' is not registered");
		}
		return this;
	}

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

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

	public IDeserializer Build()
	{
		return Deserializer.FromValueDeserializer(BuildValueDeserializer());
	}

	public IValueDeserializer BuildValueDeserializer()
	{
		return new AliasValueDeserializer(new NodeValueDeserializer(nodeDeserializerFactories.BuildComponentList(), nodeTypeResolverFactories.BuildComponentList(), typeConverter));
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.EmissionPhaseObjectGraphVisitorArgs ----
namespace YamlDotNet.Serialization
{
internal sealed class EmissionPhaseObjectGraphVisitorArgs
{
	private readonly IEnumerable<IObjectGraphVisitor<Nothing>> preProcessingPhaseVisitors;

	public IObjectGraphVisitor<IEmitter> InnerVisitor { get; private set; }

	public IEventEmitter EventEmitter { get; private set; }

	public ObjectSerializer NestedObjectSerializer { get; private set; }

	public IEnumerable<IYamlTypeConverter> TypeConverters { get; private set; }

	public EmissionPhaseObjectGraphVisitorArgs(IObjectGraphVisitor<IEmitter> innerVisitor, IEventEmitter eventEmitter, IEnumerable<IObjectGraphVisitor<Nothing>> preProcessingPhaseVisitors, IEnumerable<IYamlTypeConverter> typeConverters, ObjectSerializer nestedObjectSerializer)
	{
		InnerVisitor = innerVisitor ?? throw new ArgumentNullException("innerVisitor");
		EventEmitter = eventEmitter ?? throw new ArgumentNullException("eventEmitter");
		this.preProcessingPhaseVisitors = preProcessingPhaseVisitors ?? throw new ArgumentNullException("preProcessingPhaseVisitors");
		TypeConverters = typeConverters ?? throw new ArgumentNullException("typeConverters");
		NestedObjectSerializer = nestedObjectSerializer ?? throw new ArgumentNullException("nestedObjectSerializer");
	}

	public T GetPreProcessingPhaseObjectGraphVisitor<T>() where T : IObjectGraphVisitor<Nothing>
	{
		return preProcessingPhaseVisitors.OfType<T>().Single();
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.EventInfo ----
namespace YamlDotNet.Serialization
{
internal abstract class EventInfo
{
	public IObjectDescriptor Source { get; }

	protected EventInfo(IObjectDescriptor source)
	{
		Source = source ?? throw new ArgumentNullException("source");
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.AliasEventInfo ----
namespace YamlDotNet.Serialization
{
internal class AliasEventInfo : EventInfo
{
	public AnchorName Alias { get; }

	public bool NeedsExpansion { get; set; }

	public AliasEventInfo(IObjectDescriptor source, AnchorName alias)
		: base(source)
	{
		if (alias.IsEmpty)
		{
			throw new ArgumentNullException("alias");
		}
		Alias = alias;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.ObjectEventInfo ----
namespace YamlDotNet.Serialization
{
internal class ObjectEventInfo : EventInfo
{
	public AnchorName Anchor { get; set; }

	public TagName Tag { get; set; }

	protected ObjectEventInfo(IObjectDescriptor source)
		: base(source)
	{
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.ScalarEventInfo ----
namespace YamlDotNet.Serialization
{
internal sealed class ScalarEventInfo : ObjectEventInfo
{
	public string RenderedValue { get; set; }

	public ScalarStyle Style { get; set; }

	public bool IsPlainImplicit { get; set; }

	public bool IsQuotedImplicit { get; set; }

	public ScalarEventInfo(IObjectDescriptor source)
		: base(source)
	{
		Style = source.ScalarStyle;
		RenderedValue = string.Empty;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.MappingStartEventInfo ----
namespace YamlDotNet.Serialization
{
internal sealed class MappingStartEventInfo : ObjectEventInfo
{
	public bool IsImplicit { get; set; }

	public MappingStyle Style { get; set; }

	public MappingStartEventInfo(IObjectDescriptor source)
		: base(source)
	{
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.MappingEndEventInfo ----
namespace YamlDotNet.Serialization
{
internal sealed class MappingEndEventInfo : EventInfo
{
	public MappingEndEventInfo(IObjectDescriptor source)
		: base(source)
	{
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.SequenceStartEventInfo ----
namespace YamlDotNet.Serialization
{
internal sealed class SequenceStartEventInfo : ObjectEventInfo
{
	public bool IsImplicit { get; set; }

	public SequenceStyle Style { get; set; }

	public SequenceStartEventInfo(IObjectDescriptor source)
		: base(source)
	{
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.SequenceEndEventInfo ----
namespace YamlDotNet.Serialization
{
internal sealed class SequenceEndEventInfo : EventInfo
{
	public SequenceEndEventInfo(IObjectDescriptor source)
		: base(source)
	{
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.IAliasProvider ----
namespace YamlDotNet.Serialization
{
internal interface IAliasProvider
{
	AnchorName GetAlias(object target);
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.IDeserializer ----
namespace YamlDotNet.Serialization
{
internal interface IDeserializer
{
	T Deserialize<T>(string input);

	T Deserialize<T>(TextReader input);

	T Deserialize<T>(IParser parser);

	object? Deserialize(string input);

	object? Deserialize(TextReader input);

	object? Deserialize(IParser parser);

	object? Deserialize(string input, Type type);

	object? Deserialize(TextReader input, Type type);

	object? Deserialize(IParser parser, Type type);
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.IEventEmitter ----
namespace YamlDotNet.Serialization
{
internal interface IEventEmitter
{
	void Emit(AliasEventInfo eventInfo, IEmitter emitter);

	void Emit(ScalarEventInfo eventInfo, IEmitter emitter);

	void Emit(MappingStartEventInfo eventInfo, IEmitter emitter);

	void Emit(MappingEndEventInfo eventInfo, IEmitter emitter);

	void Emit(SequenceStartEventInfo eventInfo, IEmitter emitter);

	void Emit(SequenceEndEventInfo eventInfo, IEmitter emitter);
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.INamingConvention ----
namespace YamlDotNet.Serialization
{
internal interface INamingConvention
{
	string Apply(string value);
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.INodeDeserializer ----
namespace YamlDotNet.Serialization
{
internal interface INodeDeserializer
{
	bool Deserialize(IParser reader, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value);
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.INodeTypeResolver ----
namespace YamlDotNet.Serialization
{
internal interface INodeTypeResolver
{
	bool Resolve(NodeEvent? nodeEvent, ref Type currentType);
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.IObjectAccessor ----
namespace YamlDotNet.Serialization
{
internal interface IObjectAccessor
{
	void Set(string name, object target, object value);

	object? Read(string name, object target);
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.IObjectDescriptor ----
namespace YamlDotNet.Serialization
{
internal interface IObjectDescriptor
{
	object? Value { get; }

	Type Type { get; }

	Type StaticType { get; }

	ScalarStyle ScalarStyle { get; }
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.ObjectDescriptorExtensions ----
namespace YamlDotNet.Serialization
{
internal static class ObjectDescriptorExtensions
{
	public static object NonNullValue(this IObjectDescriptor objectDescriptor)
	{
		return objectDescriptor.Value ?? throw new InvalidOperationException("Attempted to use a IObjectDescriptor of type '" + objectDescriptor.Type.FullName + "' whose Value is null at a point whete it is invalid to do so. This may indicate a bug in YamlDotNet.");
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.IObjectFactory ----
namespace YamlDotNet.Serialization
{
internal interface IObjectFactory
{
	object Create(Type type);

	object? CreatePrimitive(Type type);

	bool GetDictionary(IObjectDescriptor descriptor, out IDictionary? dictionary, out Type[]? genericArguments);

	Type GetValueType(Type type);
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.IObjectGraphTraversalStrategy ----
namespace YamlDotNet.Serialization
{
internal interface IObjectGraphTraversalStrategy
{
	void Traverse<TContext>(IObjectDescriptor graph, IObjectGraphVisitor<TContext> visitor, TContext context);
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.IObjectGraphVisitor`1 ----
namespace YamlDotNet.Serialization
{
internal interface IObjectGraphVisitor<TContext>
{
	bool Enter(IObjectDescriptor value, TContext context);

	bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value, TContext context);

	bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, TContext context);

	void VisitScalar(IObjectDescriptor scalar, TContext context);

	void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, TContext context);

	void VisitMappingEnd(IObjectDescriptor mapping, TContext context);

	void VisitSequenceStart(IObjectDescriptor sequence, Type elementType, TContext context);

	void VisitSequenceEnd(IObjectDescriptor sequence, TContext context);
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.IPropertyDescriptor ----
namespace YamlDotNet.Serialization
{
internal interface IPropertyDescriptor
{
	string Name { get; }

	bool CanWrite { get; }

	Type Type { get; }

	Type? TypeOverride { get; set; }

	int Order { get; set; }

	ScalarStyle ScalarStyle { get; set; }

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

	IObjectDescriptor Read(object target);

	void Write(object target, object? value);
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.IRegistrationLocationSelectionSyntax`1 ----
namespace YamlDotNet.Serialization
{
internal interface IRegistrationLocationSelectionSyntax<TBaseRegistrationType>
{
	void InsteadOf<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;

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

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

	void OnTop();

	void OnBottom();
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.ITrackingRegistrationLocationSelectionSyntax`1 ----
namespace YamlDotNet.Serialization
{
internal interface ITrackingRegistrationLocationSelectionSyntax<TBaseRegistrationType>
{
	void InsteadOf<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.ISerializer ----
namespace YamlDotNet.Serialization
{
internal interface ISerializer
{
	string Serialize(object? graph);

	string Serialize(object? graph, Type type);

	void Serialize(TextWriter writer, object? graph);

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

	void Serialize(IEmitter emitter, object? graph);

	void Serialize(IEmitter emitter, object? graph, Type type);
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.ITypeInspector ----
namespace YamlDotNet.Serialization
{
internal interface ITypeInspector
{
	IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container);

	IPropertyDescriptor GetProperty(Type type, object? container, string name, [MaybeNullWhen(true)] bool ignoreUnmatched);
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.ITypeResolver ----
namespace YamlDotNet.Serialization
{
internal interface ITypeResolver
{
	Type Resolve(Type staticType, object? actualValue);
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.IValueDeserializer ----
namespace YamlDotNet.Serialization
{
internal interface IValueDeserializer
{
	object? DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer);
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.IValuePromise ----
namespace YamlDotNet.Serialization
{
internal interface IValuePromise
{
	event Action<object?> ValueAvailable;
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.IValueSerializer ----
namespace YamlDotNet.Serialization
{
internal interface IValueSerializer
{
	void SerializeValue(IEmitter emitter, object? value, Type? type);
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.IYamlConvertible ----
namespace YamlDotNet.Serialization
{
internal interface IYamlConvertible
{
	void Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer);

	void Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer);
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.ObjectDeserializer ----
namespace YamlDotNet.Serialization
{
internal delegate object? ObjectDeserializer(Type type);

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.ObjectSerializer ----
namespace YamlDotNet.Serialization
{
internal delegate void ObjectSerializer(object? value, Type? type = null);

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.IYamlSerializable ----
namespace YamlDotNet.Serialization
{
[Obsolete("Please use IYamlConvertible instead")]
internal interface IYamlSerializable
{
	void ReadYaml(IParser parser);

	void WriteYaml(IEmitter emitter);
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.IYamlTypeConverter ----
namespace YamlDotNet.Serialization
{
internal interface IYamlTypeConverter
{
	bool Accepts(Type type);

	object? ReadYaml(IParser parser, Type type);

	void WriteYaml(IEmitter emitter, object? value, Type type);
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.LazyComponentRegistrationList`2 ----
namespace YamlDotNet.Serialization
{
internal sealed class LazyComponentRegistrationList<TArgument, TComponent> : IEnumerable<Func<TArgument, TComponent>>, IEnumerable
{
	public sealed class LazyComponentRegistration
	{
		public readonly Type ComponentType;

		public readonly Func<TArgument, TComponent> Factory;

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

	public sealed class TrackingLazyComponentRegistration
	{
		public readonly Type ComponentType;

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

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

	private class RegistrationLocationSelector : IRegistrationLocationSelectionSyntax<TComponent>
	{
		private readonly LazyComponentRegistrationList<TArgument, TComponent> registrations;

		private readonly LazyComponentRegistration newRegistration;

		public RegistrationLocationSelector(LazyComponentRegistrationList<TArgument, TComponent> registrations, LazyComponentRegistration newRegistration)
		{
			this.registrations = registrations;
			this.newRegistration = newRegistration;
		}

		void IRegistrationLocationSelectionSyntax<TComponent>.InsteadOf<TRegistrationType>()
		{
			if (newRegistration.ComponentType != typeof(TRegistrationType))
			{
				registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
			}
			int index = registrations.EnsureRegistrationExists<TRegistrationType>();
			registrations.entries[index] = newRegistration;
		}

		void IRegistrationLocationSelectionSyntax<TComponent>.After<TRegistrationType>()
		{
			registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
			int num = registrations.EnsureRegistrationExists<TRegistrationType>();
			registrations.entries.Insert(num + 1, newRegistration);
		}

		void IRegistrationLocationSelectionSyntax<TComponent>.Before<TRegistrationType>()
		{
			registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
			int index = registrations.EnsureRegistrationExists<TRegistrationType>();
			registrations.entries.Insert(index, newRegistration);
		}

		void IRegistrationLocationSelectionSyntax<TComponent>.OnBottom()
		{
			registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
			registrations.entries.Add(newRegistration);
		}

		void IRegistrationLocationSelectionSyntax<TComponent>.OnTop()
		{
			registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
			registrations.entries.Insert(0, newRegistration);
		}
	}

	private class TrackingRegistrationLocationSelector : ITrackingRegistrationLocationSelectionSyntax<TComponent>
	{
		private readonly LazyComponentRegistrationList<TArgument, TComponent> registrations;

		private readonly TrackingLazyComponentRegistration newRegistration;

		public TrackingRegistrationLocationSelector(LazyComponentRegistrationList<TArgument, TComponent> registrations, TrackingLazyComponentRegistration newRegistration)
		{
			this.registrations = registrations;
			this.newRegistration = newRegistration;
		}

		void ITrackingRegistrationLocationSelectionSyntax<TComponent>.InsteadOf<TRegistrationType>()
		{
			if (newRegistration.ComponentType != typeof(TRegistrationType))
			{
				registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
			}
			int index = registrations.EnsureRegistrationExists<TRegistrationType>();
			Func<TArgument, TComponent> innerComponentFactory = registrations.entries[index].Factory;
			registrations.entries[index] = new LazyComponentRegistration(newRegistration.ComponentType, (TArgument arg) => newRegistration.Factory(innerComponentFactory(arg), arg));
		}
	}

	private readonly List<LazyComponentRegistration> entries = new List<LazyComponentRegistration>();

	public int Count => entries.Count;

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

	public LazyComponentRegistrationList<TArgument, TComponent> Clone()
	{
		LazyComponentRegistrationList<TArgument, TComponent> lazyComponentRegistrationList = new LazyComponentRegistrationList<TArgument, TComponent>();
		foreach (LazyComponentRegistration entry in entries)
		{
			lazyComponentRegistrationList.entries.Add(entry);
		}
		return lazyComponentRegistrationList;
	}

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

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

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

	public IRegistrationLocationSelectionSyntax<TComponent> CreateRegistrationLocationSelector(Type componentType, Func<TArgument, TComponent> factory)
	{
		return new RegistrationLocationSelector(this, new LazyComponentRegistration(componentType, factory));
	}

	public ITrackingRegistrationLocationSelectionSyntax<TComponent> CreateTrackingRegistrationLocationSelector(Type componentType, Func<TComponent, TArgument, TComponent> factory)
	{
		return new TrackingRegistrationLocationSelector(this, new TrackingLazyComponentRegistration(componentType, factory));
	}

	public IEnumerator<Func<TArgument, TComponent>> GetEnumerator()
	{
		return entries.Select((LazyComponentRegistration e) => e.Factory).GetEnumerator();
	}

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

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

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

	private int EnsureRegistrationExists<TRegistrationType>()
	{
		int num = IndexOfRegistration(typeof(TRegistrationType));
		if (num == -1)
		{
			throw new InvalidOperationException("A component of type '" + typeof(TRegistrationType).FullName + "' has not been registered.");
		}
		return num;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.LazyComponentRegistrationListExtensions ----
namespace YamlDotNet.Serialization
{
internal static class LazyComponentRegistrationListExtensions
{
	public static TComponent BuildComponentChain<TComponent>(this LazyComponentRegistrationList<TComponent, TComponent> registrations, TComponent innerComponent)
	{
		return registrations.InReverseOrder.Aggregate(innerComponent, (TComponent inner, Func<TComponent, TComponent> factory) => factory(inner));
	}

	public static TComponent BuildComponentChain<TArgument, TComponent>(this LazyComponentRegistrationList<TArgument, TComponent> registrations, TComponent innerComponent, Func<TComponent, TArgument> argumentBuilder)
	{
		return registrations.InReverseOrder.Aggregate(innerComponent, (TComponent inner, Func<TArgument, TComponent> factory) => factory(argumentBuilder(inner)));
	}

	public static List<TComponent> BuildComponentList<TComponent>(this LazyComponentRegistrationList<Nothing, TComponent> registrations)
	{
		return registrations.Select((Func<Nothing, TComponent> factory) => factory(default(Nothing))).ToList();
	}

	public static List<TComponent> BuildComponentList<TArgument, TComponent>(this LazyComponentRegistrationList<TArgument, TComponent> registrations, TArgument argument)
	{
		return registrations.Select((Func<TArgument, TComponent> factory) => factory(argument)).ToList();
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.Nothing ----
namespace YamlDotNet.Serialization
{
[StructLayout(LayoutKind.Sequential, Size = 1)]
internal struct Nothing
{
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.ObjectDescriptor ----
namespace YamlDotNet.Serialization
{
internal sealed class ObjectDescriptor : IObjectDescriptor
{
	public object? Value { get; private set; }

	public Type Type { get; private set; }

	public Type StaticType { get; private set; }

	public ScalarStyle ScalarStyle { get; private set; }

	public ObjectDescriptor(object? value, Type type, Type staticType)
		: this(value, type, staticType, ScalarStyle.Any)
	{
	}

	public ObjectDescriptor(object? value, Type type, Type staticType, ScalarStyle scalarStyle)
	{
		Value = value;
		Type = type ?? throw new ArgumentNullException("type");
		StaticType = staticType ?? throw new ArgumentNullException("staticType");
		ScalarStyle = scalarStyle;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.ObjectGraphTraversalStrategyFactory ----
namespace YamlDotNet.Serialization
{
internal delegate IObjectGraphTraversalStrategy ObjectGraphTraversalStrategyFactory(ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion);

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.PropertyDescriptor ----
namespace YamlDotNet.Serialization
{
internal sealed class PropertyDescriptor : IPropertyDescriptor
{
	private readonly IPropertyDescriptor baseDescriptor;

	public string Name { get; set; }

	public Type Type => baseDescriptor.Type;

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

	public int Order { get; set; }

	public ScalarStyle ScalarStyle
	{
		get
		{
			return baseDescriptor.ScalarStyle;
		}
		set
		{
			baseDescriptor.ScalarStyle = value;
		}
	}

	public bool CanWrite => baseDescriptor.CanWrite;

	public PropertyDescriptor(IPropertyDescriptor baseDescriptor)
	{
		this.baseDescriptor = baseDescriptor;
		Name = baseDescriptor.Name;
	}

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

	public T? GetCustomAttribute<T>() where T : Attribute
	{
		return baseDescriptor.GetCustomAttribute<T>();
	}

	public IObjectDescriptor Read(object target)
	{
		return baseDescriptor.Read(target);
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.Serializer ----
namespace YamlDotNet.Serialization
{
internal sealed class Serializer : ISerializer
{
	private readonly IValueSerializer valueSerializer;

	private readonly EmitterSettings emitterSettings;

	public Serializer()
		: this(new SerializerBuilder().BuildValueSerializer(), EmitterSettings.Default)
	{
	}

	private Serializer(IValueSerializer valueSerializer, EmitterSettings emitterSettings)
	{
		this.valueSerializer = valueSerializer ?? throw new ArgumentNullException("valueSerializer");
		this.emitterSettings = emitterSettings ?? throw new ArgumentNullException("emitterSettings");
	}

	public static Serializer FromValueSerializer(IValueSerializer valueSerializer, EmitterSettings emitterSettings)
	{
		return new Serializer(valueSerializer, emitterSettings);
	}

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

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

	public void Serialize(TextWriter writer, object? graph)
	{
		Serialize(new Emitter(writer, emitterSettings), graph);
	}

	public void Serialize(TextWriter writer, object? graph, Type type)
	{
		Serialize(new Emitter(writer, emitterSettings), graph, type);
	}

	public void Serialize(IEmitter emitter, object? graph)
	{
		if (emitter == null)
		{
			throw new ArgumentNullException("emitter");
		}
		EmitDocument(emitter, graph, null);
	}

	public void Serialize(IEmitter emitter, object? graph, Type type)
	{
		if (emitter == null)
		{
			throw new ArgumentNullException("emitter");
		}
		if (type == null)
		{
			throw new ArgumentNullException("type");
		}
		EmitDocument(emitter, graph, type);
	}

	private void EmitDocument(IEmitter emitter, object? graph, Type? type)
	{
		emitter.Emit(new StreamStart());
		emitter.Emit(new DocumentStart());
		valueSerializer.SerializeValue(emitter, graph, type);
		emitter.Emit(new DocumentEnd(isImplicit: true));
		emitter.Emit(new StreamEnd());
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.SerializerBuilder ----
namespace YamlDotNet.Serialization
{
internal sealed class SerializerBuilder : BuilderSkeleton<SerializerBuilder>
{
	private class ValueSerializer : IValueSerializer
	{
		private readonly IObjectGraphTraversalStrategy traversalStrategy;

		private readonly IEventEmitter eventEmitter;

		private readonly IEnumerable<IYamlTypeConverter> typeConverters;

		private readonly LazyComponentRegistrationList<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitorFactories;

		private readonly LazyComponentRegistrationList<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>> emissionPhaseObjectGraphVisitorFactories;

		public ValueSerializer(IObjectGraphTraversalStrategy traversalStrategy, IEventEmitter eventEmitter, IEnumerable<IYamlTypeConverter> typeConverters, LazyComponentRegistrationList<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitorFactories, LazyComponentRegistrationList<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>> emissionPhaseObjectGraphVisitorFactories)
		{
			this.traversalStrategy = traversalStrategy;
			this.eventEmitter = eventEmitter;
			this.typeConverters = typeConverters;
			this.preProcessingPhaseObjectGraphVisitorFactories = preProcessingPhaseObjectGraphVisitorFactories;
			this.emissionPhaseObjectGraphVisitorFactories = emissionPhaseObjectGraphVisitorFactories;
		}

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

	private ObjectGraphTraversalStrategyFactory objectGraphTraversalStrategyFactory;

	private readonly LazyComponentRegistrationList<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitorFactories;

	private readonly LazyComponentRegistrationList<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>> emissionPhaseObjectGraphVisitorFactories;

	private readonly LazyComponentRegistrationList<IEventEmitter, IEventEmitter> eventEmitterFactories;

	private readonly IDictionary<Type, TagName> tagMappings = new Dictionary<Type, TagName>();

	private readonly IObjectFactory objectFactory;

	private int maximumRecursion = 50;

	private EmitterSettings emitterSettings = EmitterSettings.Default;

	private DefaultValuesHandling defaultValuesHandlingConfiguration;

	private bool quoteNecessaryStrings;

	private bool quoteYaml1_1Strings;

	protected override SerializerBuilder Self => this;

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

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

	public SerializerBuilder WithDefaultScalarStyle(ScalarStyle style)
	{
		return WithEventEmitter((IEventEmitter inner) => new TypeAssigningEventEmitter(inner, requireTagWhenStaticAndActualTypesAreDifferent: false, tagMappings, quoteNecessaryStrings, quoteYaml1_1Strings, style), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
		{
			loc.InsteadOf<TypeAssigningEventEmitter>();
		});
	}

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

	public SerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory) where TEventEmitter : IEventEmitter
	{
		return WithEventEmitter(eventEmitterFactory, delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> w)
		{
			w.OnTop();
		});
	}

	public SerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory, Action<IRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
	{
		if (eventEmitterFactory == null)
		{
			throw new ArgumentNullException("eventEmitterFactory");
		}
		if (where == null)
		{
			throw new ArgumentNullException("where");
		}
		where(eventEmitterFactories.CreateRegistrationLocationSelector(typeof(TEventEmitter), (IEventEmitter inner) => eventEmitterFactory(inner)));
		return Self;
	}

	public SerializerBuilder WithEventEmitter<TEventEmitter>(WrapperFactory<IEventEmitter, IEventEmitter, TEventEmitter> eventEmitterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
	{
		if (eventEmitterFactory == null)
		{
			throw new ArgumentNullException("eventEmitterFactory");
		}
		if (where == null)
		{
			throw new ArgumentNullException("where");
		}
		where(eventEmitterFactories.CreateTrackingRegistrationLocationSelector(typeof(TEventEmitter), (IEventEmitter wrapped, IEventEmitter inner) => eventEmitterFactory(wrapped, inner)));
		return Self;
	}

	public SerializerBuilder WithoutEventEmitter<TEventEmitter>() where TEventEmitter : IEventEmitter
	{
		return WithoutEventEmitter(typeof(TEventEmitter));
	}

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

	public override SerializerBuilder WithTagMapping(TagName tag, Type type)
	{
		if (tag.IsEmpty)
		{
			throw new ArgumentException("Non-specific tags cannot be maped");
		}
		if (type == null)
		{
			throw new ArgumentNullException("type");
		}
		if (tagMappings.TryGetValue(type, out var value))
		{
			throw new ArgumentException($"Type already has a registered tag '{value}' for type '{type.FullName}'", "type");
		}
		tagMappings.Add(type, tag);
		return this;
	}

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

	public SerializerBuilder EnsureRoundtrip()
	{
		objectGraphTraversalStrategyFactory = (ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion) => new RoundtripObjectGraphTraversalStrategy(typeConverters, typeInspector, typeResolver, maximumRecursion, namingConvention, settings, objectFactory);
		WithEventEmitter((IEventEmitter inner) => new TypeAssigningEventEmitter(inner, requireTagWhenStaticAndActualTypesAreDifferent: true, tagMappings, quoteNecessaryStrings, quoteYaml1_1Strings), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
		{
			loc.InsteadOf<TypeAssigningEventEmitter>();
		});
		return WithTypeInspector((ITypeInspector inner) => new ReadableAndWritablePropertiesTypeInspector(inner), delegate(IRegistrationLocationSelectionSyntax<ITypeInspector> loc)
		{
			loc.OnBottom();
		});
	}

	public SerializerBuilder DisableAliases()
	{
		preProcessingPhaseObjectGraphVisitorFactories.Remove(typeof(AnchorAssigner));
		emissionPhaseObjectGraphVisitorFactories.Remove(typeof(AnchorAssigningObjectGraphVisitor));
		return this;
	}

	[Obsolete("The default behavior is now to always emit default values, thefore calling this method has no effect. This behavior is now controlled by ConfigureDefaultValuesHandling.", true)]
	public SerializerBuilder EmitDefaults()
	{
		return ConfigureDefaultValuesHandling(DefaultValuesHandling.Preserve);
	}

	public SerializerBuilder ConfigureDefaultValuesHandling(DefaultValuesHandling configuration)
	{
		defaultValuesHandlingConfiguration = configuration;
		return this;
	}

	public SerializerBuilder JsonCompatible()
	{
		emitterSettings = emitterSettings.WithMaxSimpleKeyLength(int.MaxValue).WithoutAnchorName();
		return WithTypeConverter(new GuidConverter(jsonCompatible: true), delegate(IRegistrationLocationSelectionSyntax<IYamlTypeConverter> w)
		{
			w.InsteadOf<GuidConverter>();
		}).WithTypeConverter(new DateTimeConverter(DateTimeKind.Utc, null, true)).WithEventEmitter((IEventEmitter inner) => new JsonEventEmitter(inner), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
		{
			loc.InsteadOf<TypeAssigningEventEmitter>();
		});
	}

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

	public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
	{
		return WithPreProcessingPhaseObjectGraphVisitor(objectGraphVisitor, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>> w)
		{
			w.OnTop();
		});
	}

	public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
	{
		if (objectGraphVisitor == null)
		{
			throw new ArgumentNullException("objectGraphVisitor");
		}
		if (where == null)
		{
			throw new ArgumentNullException("where");
		}
		where(preProcessingPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IEnumerable<IYamlTypeConverter> _) => objectGraphVisitor));
		return this;
	}

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

	public SerializerBuilder WithoutPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>() where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
	{
		return WithoutPreProcessingPhaseObjectGraphVisitor(typeof(TObjectGraphVisitor));
	}

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

	public SerializerBuilder WithObjectGraphTraversalStrategyFactory(ObjectGraphTraversalStrategyFactory objectGraphTraversalStrategyFactory)
	{
		this.objectGraphTraversalStrategyFactory = objectGraphTraversalStrategyFactory;
		return this;
	}

	public SerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
	{
		return WithEmissionPhaseObjectGraphVisitor(objectGraphVisitorFactory, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>> w)
		{
			w.OnTop();
		});
	}

	public SerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
	{
		if (objectGraphVisitorFactory == null)
		{
			throw new ArgumentNullException("objectGraphVisitorFactory");
		}
		if (where == null)
		{
			throw new ArgumentNullException("where");
		}
		where(emissionPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory(args)));
		return this;
	}

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

	public SerializerBuilder WithoutEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>() where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
	{
		return WithoutEmissionPhaseObjectGraphVisitor(typeof(TObjectGraphVisitor));
	}

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

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

	public ISerializer Build()
	{
		return Serializer.FromValueSerializer(BuildValueSerializer(), emitterSettings);
	}

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

	internal ITypeInspector BuildTypeInspector()
	{
		ITypeInspector typeInspector = new ReadablePropertiesTypeInspector(typeResolver, includeNonPublicProperties);
		if (!ignoreFields)
		{
			typeInspector = new CompositeTypeInspector(new ReadableFieldsTypeInspector(typeResolver), typeInspector);
		}
		return typeInspectorFactories.BuildComponentChain(typeInspector);
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.Settings ----
namespace YamlDotNet.Serialization
{
internal class Settings
{
	public bool AllowPrivateConstructors { get; set; }
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.StaticBuilderSkeleton`1 ----
namespace YamlDotNet.Serialization
{
internal abstract class StaticBuilderSkeleton<TBuilder> where TBuilder : StaticBuilderSkeleton<TBuilder>
{
	internal INamingConvention namingConvention = NullNamingConvention.Instance;

	internal ITypeResolver typeResolver;

	internal readonly LazyComponentRegistrationList<Nothing, IYamlTypeConverter> typeConverterFactories;

	internal readonly LazyComponentRegistrationList<ITypeInspector, ITypeInspector> typeInspectorFactories;

	internal bool includeNonPublicProperties;

	internal Settings settings;

	protected abstract TBuilder Self { get; }

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

	public TBuilder WithNamingConvention(INamingConvention namingConvention)
	{
		this.namingConvention = namingConvention ?? throw new ArgumentNullException("namingConvention");
		return Self;
	}

	public TBuilder WithTypeResolver(ITypeResolver typeResolver)
	{
		this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
		return Self;
	}

	public abstract TBuilder WithTagMapping(TagName tag, Type type);

	public TBuilder WithTypeConverter(IYamlTypeConverter typeConverter)
	{
		return WithTypeConverter(typeConverter, delegate(IRegistrationLocationSelectionSyntax<IYamlTypeConverter> w)
		{
			w.OnTop();
		});
	}

	public TBuilder WithTypeConverter(IYamlTypeConverter typeConverter, Action<IRegistrationLocationSelectionSyntax<IYamlTypeConverter>> where)
	{
		if (typeConverter == null)
		{
			throw new ArgumentNullException("typeConverter");
		}
		if (where == null)
		{
			throw new ArgumentNullException("where");
		}
		where(typeConverterFactories.CreateRegistrationLocationSelector(typeConverter.GetType(), (Nothing _) => typeConverter));
		return Self;
	}

	public TBuilder WithTypeConverter<TYamlTypeConverter>(WrapperFactory<IYamlTypeConverter, IYamlTypeConverter> typeConverterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IYamlTypeConverter>> where) where TYamlTypeConverter : IYamlTypeConverter
	{
		if (typeConverterFactory == null)
		{
			throw new ArgumentNullException("typeConverterFactory");
		}
		if (where == null)
		{
			throw new ArgumentNullException("where");
		}
		where(typeConverterFactories.CreateTrackingRegistrationLocationSelector(typeof(TYamlTypeConverter), (IYamlTypeConverter wrapped, Nothing _) => typeConverterFactory(wrapped)));
		return Self;
	}

	public TBuilder WithoutTypeConverter<TYamlTypeConverter>() where TYamlTypeConverter : IYamlTypeConverter
	{
		return WithoutTypeConverter(typeof(TYamlTypeConverter));
	}

	public TBuilder WithoutTypeConverter(Type converterType)
	{
		if (converterType == null)
		{
			throw new ArgumentNullException("converterType");
		}
		typeConverterFactories.Remove(converterType);
		return Self;
	}

	public TBuilder WithTypeInspector<TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory) where TTypeInspector : ITypeInspector
	{
		return WithTypeInspector(typeInspectorFactory, delegate(IRegistrationLocationSelectionSyntax<ITypeInspector> w)
		{
			w.OnTop();
		});
	}

	public TBuilder WithTypeInspector<TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory, Action<IRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
	{
		if (typeInspectorFactory == null)
		{
			throw new ArgumentNullException("typeInspectorFactory");
		}
		if (where == null)
		{
			throw new ArgumentNullException("where");
		}
		where(typeInspectorFactories.CreateRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector inner) => typeInspectorFactory(inner)));
		return Self;
	}

	public TBuilder WithTypeInspector<TTypeInspector>(WrapperFactory<ITypeInspector, ITypeInspector, TTypeInspector> typeInspectorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
	{
		if (typeInspectorFactory == null)
		{
			throw new ArgumentNullException("typeInspectorFactory");
		}
		if (where == null)
		{
			throw new ArgumentNullException("where");
		}
		where(typeInspectorFactories.CreateTrackingRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector wrapped, ITypeInspector inner) => typeInspectorFactory(wrapped, inner)));
		return Self;
	}

	public TBuilder WithoutTypeInspector<TTypeInspector>() where TTypeInspector : ITypeInspector
	{
		return WithoutTypeInspector(typeof(TTypeInspector));
	}

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

	protected IEnumerable<IYamlTypeConverter> BuildTypeConverters()
	{
		return typeConverterFactories.BuildComponentList();
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.StaticContext ----
namespace YamlDotNet.Serialization
{
internal abstract class StaticContext
{
	public virtual StaticObjectFactory GetFactory()
	{
		throw new NotImplementedException();
	}

	public virtual ITypeInspector GetTypeInspector()
	{
		throw new NotImplementedException();
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.StaticDeserializerBuilder ----
namespace YamlDotNet.Serialization
{
internal sealed class StaticDeserializerBuilder : StaticBuilderSkeleton<StaticDeserializerBuilder>
{
	private readonly StaticContext context;

	private readonly StaticObjectFactory factory;

	private readonly LazyComponentRegistrationList<Nothing, INodeDeserializer> nodeDeserializerFactories;

	private readonly LazyComponentRegistrationList<Nothing, INodeTypeResolver> nodeTypeResolverFactories;

	private readonly Dictionary<TagName, Type> tagMappings;

	private readonly ITypeConverter typeConverter;

	private readonly Dictionary<Type, Type> typeMappings;

	private bool ignoreUnmatched;

	private bool duplicateKeyChecking;

	private bool attemptUnknownTypeDeserialization;

	protected override StaticDeserializerBuilder Self => this;

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

	internal ITypeInspector BuildTypeInspector()
	{
		ITypeInspector typeInspector = context.GetTypeInspector();
		return typeInspectorFactories.BuildComponentChain(typeInspector);
	}

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

	public StaticDeserializerBuilder WithNodeDeserializer(INodeDeserializer nodeDeserializer)
	{
		return WithNodeDeserializer(nodeDeserializer, delegate(IRegistrationLocationSelectionSyntax<INodeDeserializer> w)
		{
			w.OnTop();
		});
	}

	public StaticDeserializerBuilder WithNodeDeserializer(INodeDeserializer nodeDeserializer, Action<IRegistrationLocationSelectionSyntax<INodeDeserializer>> where)
	{
		if (nodeDeserializer == null)
		{
			throw new ArgumentNullException("nodeDeserializer");
		}
		if (where == null)
		{
			throw new ArgumentNullException("where");
		}
		where(nodeDeserializerFactories.CreateRegistrationLocationSelector(nodeDeserializer.GetType(), (Nothing _) => nodeDeserializer));
		return this;
	}

	public StaticDeserializerBuilder WithNodeDeserializer<TNodeDeserializer>(WrapperFactory<INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeDeserializer>> where) where TNodeDeserializer : INodeDeserializer
	{
		if (nodeDeserializerFactory == null)
		{
			throw new ArgumentNullException("nodeDeserializerFactory");
		}
		if (where == null)
		{
			throw new ArgumentNullException("where");
		}
		where(nodeDeserializerFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeDeserializer), (INodeDeserializer wrapped, Nothing _) => nodeDeserializerFactory(wrapped)));
		return this;
	}

	public StaticDeserializerBuilder WithoutNodeDeserializer<TNodeDeserializer>() where TNodeDeserializer : INodeDeserializer
	{
		return WithoutNodeDeserializer(typeof(TNodeDeserializer));
	}

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

	public StaticDeserializerBuilder WithTypeDiscriminatingNodeDeserializer(Action<ITypeDiscriminatingNodeDeserializerOptions> configureTypeDiscriminatingNodeDeserializerOptions, int maxDepth = -1, int maxLength = -1)
	{
		TypeDiscriminatingNodeDeserializerOptions typeDiscriminatingNodeDeserializerOptions = new TypeDiscriminatingNodeDeserializerOptions();
		configureTypeDiscriminatingNodeDeserializerOptions(typeDiscriminatingNodeDeserializerOptions);
		TypeDiscriminatingNodeDeserializer nodeDeserializer = new TypeDiscriminatingNodeDeserializer(nodeDeserializerFactories.BuildComponentList(), typeDiscriminatingNodeDeserializerOptions.discriminators, maxDepth, maxLength);
		return WithNodeDeserializer(nodeDeserializer, delegate(IRegistrationLocationSelectionSyntax<INodeDeserializer> s)
		{
			s.Before<DictionaryNodeDeserializer>();
		});
	}

	public StaticDeserializerBuilder WithNodeTypeResolver(INodeTypeResolver nodeTypeResolver)
	{
		return WithNodeTypeResolver(nodeTypeResolver, delegate(IRegistrationLocationSelectionSyntax<INodeTypeResolver> w)
		{
			w.OnTop();
		});
	}

	public StaticDeserializerBuilder WithNodeTypeResolver(INodeTypeResolver nodeTypeResolver, Action<IRegistrationLocationSelectionSyntax<INodeTypeResolver>> where)
	{
		if (nodeTypeResolver == null)
		{
			throw new ArgumentNullException("nodeTypeResolver");
		}
		if (where == null)
		{
			throw new ArgumentNullException("where");
		}
		where(nodeTypeResolverFactories.CreateRegistrationLocationSelector(nodeTypeResolver.GetType(), (Nothing _) => nodeTypeResolver));
		return this;
	}

	public StaticDeserializerBuilder WithNodeTypeResolver<TNodeTypeResolver>(WrapperFactory<INodeTypeResolver, TNodeTypeResolver> nodeTypeResolverFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeTypeResolver>> where) where TNodeTypeResolver : INodeTypeResolver
	{
		if (nodeTypeResolverFactory == null)
		{
			throw new ArgumentNullException("nodeTypeResolverFactory");
		}
		if (where == null)
		{
			throw new ArgumentNullException("where");
		}
		where(nodeTypeResolverFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeTypeResolver), (INodeTypeResolver wrapped, Nothing _) => nodeTypeResolverFactory(wrapped)));
		return this;
	}

	public StaticDeserializerBuilder WithoutNodeTypeResolver<TNodeTypeResolver>() where TNodeTypeResolver : INodeTypeResolver
	{
		return WithoutNodeTypeResolver(typeof(TNodeTypeResolver));
	}

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

	public override StaticDeserializerBuilder WithTagMapping(TagName tag, Type type)
	{
		if (tag.IsEmpty)
		{
			throw new ArgumentException("Non-specific tags cannot be maped");
		}
		if (type == null)
		{
			throw new ArgumentNullException("type");
		}
		if (tagMappings.TryGetValue(tag, out Type value))
		{
			throw new ArgumentException($"Type already has a registered type '{value.FullName}' for tag '{tag}'", "tag");
		}
		tagMappings.Add(tag, type);
		return this;
	}

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

	public StaticDeserializerBuilder WithoutTagMapping(TagName tag)
	{
		if (tag.IsEmpty)
		{
			throw new ArgumentException("Non-specific tags cannot be maped");
		}
		if (!tagMappings.Remove(tag))
		{
			throw new KeyNotFoundException($"Tag '{tag}' is not registered");
		}
		return this;
	}

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

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

	public IDeserializer Build()
	{
		return Deserializer.FromValueDeserializer(BuildValueDeserializer());
	}

	public IValueDeserializer BuildValueDeserializer()
	{
		return new AliasValueDeserializer(new NodeValueDeserializer(nodeDeserializerFactories.BuildComponentList(), nodeTypeResolverFactories.BuildComponentList(), typeConverter));
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.StaticSerializerBuilder ----
namespace YamlDotNet.Serialization
{
internal sealed class StaticSerializerBuilder : StaticBuilderSkeleton<StaticSerializerBuilder>
{
	private class ValueSerializer : IValueSerializer
	{
		private readonly IObjectGraphTraversalStrategy traversalStrategy;

		private readonly IEventEmitter eventEmitter;

		private readonly IEnumerable<IYamlTypeConverter> typeConverters;

		private readonly LazyComponentRegistrationList<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitorFactories;

		private readonly LazyComponentRegistrationList<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>> emissionPhaseObjectGraphVisitorFactories;

		public ValueSerializer(IObjectGraphTraversalStrategy traversalStrategy, IEventEmitter eventEmitter, IEnumerable<IYamlTypeConverter> typeConverters, LazyComponentRegistrationList<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitorFactories, LazyComponentRegistrationList<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>> emissionPhaseObjectGraphVisitorFactories)
		{
			this.traversalStrategy = traversalStrategy;
			this.eventEmitter = eventEmitter;
			this.typeConverters = typeConverters;
			this.preProcessingPhaseObjectGraphVisitorFactories = preProcessingPhaseObjectGraphVisitorFactories;
			this.emissionPhaseObjectGraphVisitorFactories = emissionPhaseObjectGraphVisitorFactories;
		}

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

	private readonly StaticContext context;

	private readonly StaticObjectFactory factory;

	private ObjectGraphTraversalStrategyFactory objectGraphTraversalStrategyFactory;

	private readonly LazyComponentRegistrationList<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitorFactories;

	private readonly LazyComponentRegistrationList<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>> emissionPhaseObjectGraphVisitorFactories;

	private readonly LazyComponentRegistrationList<IEventEmitter, IEventEmitter> eventEmitterFactories;

	private readonly IDictionary<Type, TagName> tagMappings = new Dictionary<Type, TagName>();

	private int maximumRecursion = 50;

	private EmitterSettings emitterSettings = EmitterSettings.Default;

	private DefaultValuesHandling defaultValuesHandlingConfiguration;

	private bool quoteNecessaryStrings;

	protected override StaticSerializerBuilder Self => this;

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

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

	public StaticSerializerBuilder WithDefaultScalarStyle(ScalarStyle style)
	{
		return WithEventEmitter((IEventEmitter inner) => new TypeAssigningEventEmitter(inner, requireTagWhenStaticAndActualTypesAreDifferent: false, tagMappings, quoteNecessaryStrings, style), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
		{
			loc.InsteadOf<TypeAssigningEventEmitter>();
		});
	}

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

	public StaticSerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory) where TEventEmitter : IEventEmitter
	{
		return WithEventEmitter(eventEmitterFactory, delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> w)
		{
			w.OnTop();
		});
	}

	public StaticSerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory, Action<IRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
	{
		if (eventEmitterFactory == null)
		{
			throw new ArgumentNullException("eventEmitterFactory");
		}
		if (where == null)
		{
			throw new ArgumentNullException("where");
		}
		where(eventEmitterFactories.CreateRegistrationLocationSelector(typeof(TEventEmitter), (IEventEmitter inner) => eventEmitterFactory(inner)));
		return Self;
	}

	public StaticSerializerBuilder WithEventEmitter<TEventEmitter>(WrapperFactory<IEventEmitter, IEventEmitter, TEventEmitter> eventEmitterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
	{
		if (eventEmitterFactory == null)
		{
			throw new ArgumentNullException("eventEmitterFactory");
		}
		if (where == null)
		{
			throw new ArgumentNullException("where");
		}
		where(eventEmitterFactories.CreateTrackingRegistrationLocationSelector(typeof(TEventEmitter), (IEventEmitter wrapped, IEventEmitter inner) => eventEmitterFactory(wrapped, inner)));
		return Self;
	}

	public StaticSerializerBuilder WithoutEventEmitter<TEventEmitter>() where TEventEmitter : IEventEmitter
	{
		return WithoutEventEmitter(typeof(TEventEmitter));
	}

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

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

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

	public StaticSerializerBuilder EnsureRoundtrip()
	{
		objectGraphTraversalStrategyFactory = (ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion) => new RoundtripObjectGraphTraversalStrategy(typeConverters, typeInspector, typeResolver, maximumRecursion, namingConvention, settings, factory);
		WithEventEmitter((IEventEmitter inner) => new TypeAssigningEventEmitter(inner, requireTagWhenStaticAndActualTypesAreDifferent: true, tagMappings, quoteNecessaryStrings), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
		{
			loc.InsteadOf<TypeAssigningEventEmitter>();
		});
		return WithTypeInspector((ITypeInspector inner) => new ReadableAndWritablePropertiesTypeInspector(inner), delegate(IRegistrationLocationSelectionSyntax<ITypeInspector> loc)
		{
			loc.OnBottom();
		});
	}

	public StaticSerializerBuilder DisableAliases()
	{
		preProcessingPhaseObjectGraphVisitorFactories.Remove(typeof(AnchorAssigner));
		emissionPhaseObjectGraphVisitorFactories.Remove(typeof(AnchorAssigningObjectGraphVisitor));
		return this;
	}

	[Obsolete("The default behavior is now to always emit default values, thefore calling this method has no effect. This behavior is now controlled by ConfigureDefaultValuesHandling.", true)]
	public StaticSerializerBuilder EmitDefaults()
	{
		return ConfigureDefaultValuesHandling(DefaultValuesHandling.Preserve);
	}

	public StaticSerializerBuilder ConfigureDefaultValuesHandling(DefaultValuesHandling configuration)
	{
		defaultValuesHandlingConfiguration = configuration;
		return this;
	}

	public StaticSerializerBuilder JsonCompatible()
	{
		emitterSettings = emitterSettings.WithMaxSimpleKeyLength(int.MaxValue).WithoutAnchorName();
		return WithTypeConverter(new GuidConverter(jsonCompatible: true), delegate(IRegistrationLocationSelectionSyntax<IYamlTypeConverter> w)
		{
			w.InsteadOf<GuidConverter>();
		}).WithEventEmitter((IEventEmitter inner) => new JsonEventEmitter(inner), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
		{
			loc.InsteadOf<TypeAssigningEventEmitter>();
		});
	}

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

	public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
	{
		return WithPreProcessingPhaseObjectGraphVisitor(objectGraphVisitor, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>> w)
		{
			w.OnTop();
		});
	}

	public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
	{
		if (objectGraphVisitor == null)
		{
			throw new ArgumentNullException("objectGraphVisitor");
		}
		if (where == null)
		{
			throw new ArgumentNullException("where");
		}
		where(preProcessingPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IEnumerable<IYamlTypeConverter> _) => objectGraphVisitor));
		return this;
	}

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

	public StaticSerializerBuilder WithoutPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>() where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
	{
		return WithoutPreProcessingPhaseObjectGraphVisitor(typeof(TObjectGraphVisitor));
	}

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

	public StaticSerializerBuilder WithObjectGraphTraversalStrategyFactory(ObjectGraphTraversalStrategyFactory objectGraphTraversalStrategyFactory)
	{
		this.objectGraphTraversalStrategyFactory = objectGraphTraversalStrategyFactory;
		return this;
	}

	public StaticSerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
	{
		return WithEmissionPhaseObjectGraphVisitor(objectGraphVisitorFactory, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>> w)
		{
			w.OnTop();
		});
	}

	public StaticSerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
	{
		if (objectGraphVisitorFactory == null)
		{
			throw new ArgumentNullException("objectGraphVisitorFactory");
		}
		if (where == null)
		{
			throw new ArgumentNullException("where");
		}
		where(emissionPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory(args)));
		return this;
	}

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

	public StaticSerializerBuilder WithoutEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>() where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
	{
		return WithoutEmissionPhaseObjectGraphVisitor(typeof(TObjectGraphVisitor));
	}

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

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

	public ISerializer Build()
	{
		return Serializer.FromValueSerializer(BuildValueSerializer(), emitterSettings);
	}

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

	internal ITypeInspector BuildTypeInspector()
	{
		ITypeInspector typeInspector = context.GetTypeInspector();
		return typeInspectorFactories.BuildComponentChain(typeInspector);
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.StreamFragment ----
namespace YamlDotNet.Serialization
{
internal sealed class StreamFragment : IYamlConvertible
{
	private readonly List<ParsingEvent> events = new List<ParsingEvent>();

	public IList<ParsingEvent> Events => events;

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

	void IYamlConvertible.Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer)
	{
		foreach (ParsingEvent @event in events)
		{
			emitter.Emit(@event);
		}
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.TagMappings ----
namespace YamlDotNet.Serialization
{
internal sealed class TagMappings
{
	private readonly IDictionary<string, Type> mappings;

	public TagMappings()
	{
		mappings = new Dictionary<string, Type>();
	}

	public TagMappings(IDictionary<string, Type> mappings)
	{
		this.mappings = new Dictionary<string, Type>(mappings);
	}

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

	internal Type? GetMapping(string tag)
	{
		if (!mappings.TryGetValue(tag, out Type value))
		{
			return null;
		}
		return value;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.YamlAttributeOverrides ----
namespace YamlDotNet.Serialization
{
internal sealed class YamlAttributeOverrides
{
	private struct AttributeKey(Type attributeType, string propertyName)
	{
		public readonly Type AttributeType = attributeType;

		public readonly string PropertyName = propertyName;

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

		public override int GetHashCode()
		{
			return YamlDotNet.Core.HashCode.CombineHashCodes(AttributeType.GetHashCode(), PropertyName.GetHashCode());
		}
	}

	private sealed class AttributeMapping
	{
		public readonly Type RegisteredType;

		public readonly Attribute Attribute;

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

		public override bool Equals(object? obj)
		{
			if (obj is AttributeMapping attributeMapping && RegisteredType.Equals(attributeMapping.RegisteredType))
			{
				return Attribute.Equals(attributeMapping.Attribute);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return YamlDotNet.Core.HashCode.CombineHashCodes(RegisteredType.GetHashCode(), Attribute.GetHashCode());
		}

		public int Matches(Type matchType)
		{
			int num = 0;
			Type type = matchType;
			while (type != null)
			{
				num++;
				if (type == RegisteredType)
				{
					return num;
				}
				type = type.BaseType();
			}
			if (matchType.GetInterfaces().Contains<Type>(RegisteredType))
			{
				return num;
			}
			return 0;
		}
	}

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

	[return: MaybeNull]
	public T GetAttribute<T>(Type type, string member) where T : Attribute
	{
		if (overrides.TryGetValue(new AttributeKey(typeof(T), member), out List<AttributeMapping> value))
		{
			int num = 0;
			AttributeMapping attributeMapping = null;
			foreach (AttributeMapping item in value)
			{
				int num2 = item.Matches(type);
				if (num2 > num)
				{
					num = num2;
					attributeMapping = item;
				}
			}
			if (num > 0)
			{
				return (T)attributeMapping.Attribute;
			}
		}
		return null;
	}

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

	public YamlAttributeOverrides Clone()
	{
		YamlAttributeOverrides yamlAttributeOverrides = new YamlAttributeOverrides();
		foreach (KeyValuePair<AttributeKey, List<AttributeMapping>> @override in overrides)
		{
			foreach (AttributeMapping item in @override.Value)
			{
				yamlAttributeOverrides.Add(item.RegisteredType, @override.Key.PropertyName, item.Attribute);
			}
		}
		return yamlAttributeOverrides;
	}

	public void Add<TClass>(Expression<Func<TClass, object>> propertyAccessor, Attribute attribute)
	{
		PropertyInfo propertyInfo = propertyAccessor.AsProperty();
		Add(typeof(TClass), propertyInfo.Name, attribute);
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.YamlAttributeOverridesInspector ----
namespace YamlDotNet.Serialization
{
internal sealed class YamlAttributeOverridesInspector : TypeInspectorSkeleton
{
	public sealed class OverridePropertyDescriptor : IPropertyDescriptor
	{
		private readonly IPropertyDescriptor baseDescriptor;

		private readonly YamlAttributeOverrides overrides;

		private readonly Type classType;

		public string Name => baseDescriptor.Name;

		public bool CanWrite => baseDescriptor.CanWrite;

		public Type Type => baseDescriptor.Type;

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

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

		public ScalarStyle ScalarStyle
		{
			get
			{
				return baseDescriptor.ScalarStyle;
			}
			set
			{
				baseDescriptor.ScalarStyle = value;
			}
		}

		public OverridePropertyDescriptor(IPropertyDescriptor baseDescriptor, YamlAttributeOverrides overrides, Type classType)
		{
			this.baseDescriptor = baseDescriptor;
			this.overrides = overrides;
			this.classType = classType;
		}

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

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

		public IObjectDescriptor Read(object target)
		{
			return baseDescriptor.Read(target);
		}
	}

	private readonly ITypeInspector innerTypeDescriptor;

	private readonly YamlAttributeOverrides overrides;

	public YamlAttributeOverridesInspector(ITypeInspector innerTypeDescriptor, YamlAttributeOverrides overrides)
	{
		this.innerTypeDescriptor = innerTypeDescriptor;
		this.overrides = overrides;
	}

	public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
	{
		IEnumerable<IPropertyDescriptor> enumerable = innerTypeDescriptor.GetProperties(type, container);
		if (overrides != null)
		{
			enumerable = enumerable.Select((Func<IPropertyDescriptor, IPropertyDescriptor>)((IPropertyDescriptor p) => new OverridePropertyDescriptor(p, overrides, type)));
		}
		return enumerable;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.YamlAttributesTypeInspector ----
namespace YamlDotNet.Serialization
{
internal sealed class YamlAttributesTypeInspector : TypeInspectorSkeleton
{
	private readonly ITypeInspector innerTypeDescriptor;

	public YamlAttributesTypeInspector(ITypeInspector innerTypeDescriptor)
	{
		this.innerTypeDescriptor = innerTypeDescriptor;
	}

	public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
	{
		return from p in (from p in innerTypeDescriptor.GetProperties(type, container)
				where p.GetCustomAttribute<YamlIgnoreAttribute>() == null
				select p).Select((Func<IPropertyDescriptor, IPropertyDescriptor>)delegate(IPropertyDescriptor p)
			{
				PropertyDescriptor propertyDescriptor = new PropertyDescriptor(p);
				YamlMemberAttribute customAttribute = p.GetCustomAttribute<YamlMemberAttribute>();
				if (customAttribute != null)
				{
					if (customAttribute.SerializeAs != null)
					{
						propertyDescriptor.TypeOverride = customAttribute.SerializeAs;
					}
					propertyDescriptor.Order = customAttribute.Order;
					propertyDescriptor.ScalarStyle = customAttribute.ScalarStyle;
					if (customAttribute.Alias != null)
					{
						propertyDescriptor.Name = customAttribute.Alias;
					}
				}
				return propertyDescriptor;
			})
			orderby p.Order
			select p;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.YamlFormatter ----
namespace YamlDotNet.Serialization
{
internal static class YamlFormatter
{
	public static readonly NumberFormatInfo NumberFormat = new NumberFormatInfo
	{
		CurrencyDecimalSeparator = ".",
		CurrencyGroupSeparator = "_",
		CurrencyGroupSizes = new int[1] { 3 },
		CurrencySymbol = string.Empty,
		CurrencyDecimalDigits = 99,
		NumberDecimalSeparator = ".",
		NumberGroupSeparator = "_",
		NumberGroupSizes = new int[1] { 3 },
		NumberDecimalDigits = 99,
		NaNSymbol = ".nan",
		PositiveInfinitySymbol = ".inf",
		NegativeInfinitySymbol = "-.inf"
	};

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

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

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

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

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

	public static string FormatTimeSpan(object timeSpan)
	{
		return ((TimeSpan)timeSpan/*cast due to constrained. prefix*//*cast due to constrained. prefix*/).ToString();
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.YamlIgnoreAttribute ----
namespace YamlDotNet.Serialization
{
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
internal sealed class YamlIgnoreAttribute : Attribute
{
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.YamlMemberAttribute ----
namespace YamlDotNet.Serialization
{
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
internal sealed class YamlMemberAttribute : Attribute
{
	private DefaultValuesHandling? defaultValuesHandling;

	public string? Description { get; set; }

	public Type? SerializeAs { get; set; }

	public int Order { get; set; }

	public string? Alias { get; set; }

	public bool ApplyNamingConventions { get; set; }

	public ScalarStyle ScalarStyle { get; set; }

	public DefaultValuesHandling DefaultValuesHandling
	{
		get
		{
			return defaultValuesHandling.GetValueOrDefault();
		}
		set
		{
			defaultValuesHandling = value;
		}
	}

	public bool IsDefaultValuesHandlingSpecified => defaultValuesHandling.HasValue;

	public YamlMemberAttribute()
	{
		ScalarStyle = ScalarStyle.Any;
		ApplyNamingConventions = true;
	}

	public YamlMemberAttribute(Type serializeAs)
		: this()
	{
		SerializeAs = serializeAs ?? throw new ArgumentNullException("serializeAs");
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.YamlSerializableAttribute ----
namespace YamlDotNet.Serialization
{
[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
internal sealed class YamlSerializableAttribute : Attribute
{
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.YamlStaticContextAttribute ----
namespace YamlDotNet.Serialization
{
internal sealed class YamlStaticContextAttribute : Attribute
{
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.ValueDeserializers.AliasValueDeserializer ----
namespace YamlDotNet.Serialization.ValueDeserializers
{
internal sealed class AliasValueDeserializer : IValueDeserializer
{
	private sealed class AliasState : Dictionary<AnchorName, ValuePromise>, IPostDeserializationCallback
	{
		public void OnDeserialization()
		{
			foreach (ValuePromise value in base.Values)
			{
				if (!value.HasValue)
				{
					AnchorAlias alias = value.Alias;
					throw new AnchorNotFoundException(alias.Start, alias.End, $"Anchor '{alias.Value}' not found");
				}
			}
		}
	}

	private sealed class ValuePromise : IValuePromise
	{
		private object? value;

		public readonly AnchorAlias? Alias;

		public bool HasValue { get; private set; }

		public object? Value
		{
			get
			{
				if (!HasValue)
				{
					throw new InvalidOperationException("Value not set");
				}
				return value;
			}
			set
			{
				if (HasValue)
				{
					throw new InvalidOperationException("Value already set");
				}
				HasValue = true;
				this.value = value;
				this.ValueAvailable?.Invoke(value);
			}
		}

		public event Action<object?>? ValueAvailable;

		public ValuePromise(AnchorAlias alias)
		{
			Alias = alias;
		}

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

	private readonly IValueDeserializer innerDeserializer;

	public AliasValueDeserializer(IValueDeserializer innerDeserializer)
	{
		this.innerDeserializer = innerDeserializer ?? throw new ArgumentNullException("innerDeserializer");
	}

	public object? DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
	{
		if (parser.TryConsume<AnchorAlias>(out var @event))
		{
			if (!state.Get<AliasState>().TryGetValue(@event.Value, out ValuePromise value))
			{
				throw new AnchorNotFoundException(@event.Start, @event.End, $"Alias ${@event.Value} cannot precede anchor declaration");
			}
			if (!value.HasValue)
			{
				return value;
			}
			return value.Value;
		}
		AnchorName anchorName = AnchorName.Empty;
		if (parser.Accept<NodeEvent>(out var event2) && !event2.Anchor.IsEmpty)
		{
			anchorName = event2.Anchor;
			AliasState aliasState = state.Get<AliasState>();
			if (!aliasState.ContainsKey(anchorName))
			{
				aliasState[anchorName] = new ValuePromise(new AnchorAlias(anchorName));
			}
		}
		object obj = innerDeserializer.DeserializeValue(parser, expectedType, state, nestedObjectDeserializer);
		if (!anchorName.IsEmpty)
		{
			AliasState aliasState2 = state.Get<AliasState>();
			if (!aliasState2.TryGetValue(anchorName, out ValuePromise value2))
			{
				aliasState2.Add(anchorName, new ValuePromise(obj));
			}
			else if (!value2.HasValue)
			{
				value2.Value = obj;
			}
			else
			{
				aliasState2[anchorName] = new ValuePromise(obj);
			}
		}
		return obj;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.ValueDeserializers.NodeValueDeserializer ----
namespace YamlDotNet.Serialization.ValueDeserializers
{
internal sealed class NodeValueDeserializer : IValueDeserializer
{
	private readonly IList<INodeDeserializer> deserializers;

	private readonly IList<INodeTypeResolver> typeResolvers;

	private readonly ITypeConverter typeConverter;

	public NodeValueDeserializer(IList<INodeDeserializer> deserializers, IList<INodeTypeResolver> typeResolvers, ITypeConverter typeConverter)
	{
		this.deserializers = deserializers ?? throw new ArgumentNullException("deserializers");
		this.typeResolvers = typeResolvers ?? throw new ArgumentNullException("typeResolvers");
		this.typeConverter = typeConverter ?? throw new ArgumentNullException("typeConverter");
	}

	public object? DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
	{
		parser.Accept<NodeEvent>(out var @event);
		Type typeFromEvent = GetTypeFromEvent(@event, expectedType);
		try
		{
			foreach (INodeDeserializer deserializer in deserializers)
			{
				if (deserializer.Deserialize(parser, typeFromEvent, (IParser r, Type t) => nestedObjectDeserializer.DeserializeValue(r, t, state, nestedObjectDeserializer), out object value))
				{
					return typeConverter.ChangeType(value, expectedType);
				}
			}
		}
		catch (YamlException)
		{
			throw;
		}
		catch (Exception innerException)
		{
			throw new YamlException(@event?.Start ?? Mark.Empty, @event?.End ?? Mark.Empty, "Exception during deserialization", innerException);
		}
		throw new YamlException(@event?.Start ?? Mark.Empty, @event?.End ?? Mark.Empty, "No node deserializer was able to deserialize the node into type " + expectedType.AssemblyQualifiedName);
	}

	private Type GetTypeFromEvent(NodeEvent? nodeEvent, Type currentType)
	{
		using (IEnumerator<INodeTypeResolver> enumerator = typeResolvers.GetEnumerator())
		{
			while (enumerator.MoveNext() && !enumerator.Current.Resolve(nodeEvent, ref currentType))
			{
			}
		}
		return currentType;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.Utilities.IPostDeserializationCallback ----
namespace YamlDotNet.Serialization.Utilities
{
internal interface IPostDeserializationCallback
{
	void OnDeserialization();
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.Utilities.ITypeConverter ----
namespace YamlDotNet.Serialization.Utilities
{
internal interface ITypeConverter
{
	object? ChangeType(object? value, Type expectedType);
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.Utilities.NullTypeConverter ----
namespace YamlDotNet.Serialization.Utilities
{
internal class NullTypeConverter : ITypeConverter
{
	public object? ChangeType(object? value, Type expectedType)
	{
		return value;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.Utilities.ObjectAnchorCollection ----
namespace YamlDotNet.Serialization.Utilities
{
internal sealed class ObjectAnchorCollection
{
	private readonly IDictionary<string, object> objectsByAnchor = new Dictionary<string, object>();

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

	public object this[string anchor]
	{
		get
		{
			if (objectsByAnchor.TryGetValue(anchor, out object value))
			{
				return value;
			}
			throw new AnchorNotFoundException("The anchor '" + anchor + "' does not exists");
		}
	}

	public void Add(string anchor, object @object)
	{
		objectsByAnchor.Add(anchor, @object);
		if (@object != null)
		{
			anchorsByObject.Add(@object, anchor);
		}
	}

	public bool TryGetAnchor(object @object, [MaybeNullWhen(false)] out string? anchor)
	{
		return anchorsByObject.TryGetValue(@object, out anchor);
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.Utilities.ReflectionTypeConverter ----
namespace YamlDotNet.Serialization.Utilities
{
internal class ReflectionTypeConverter : ITypeConverter
{
	public object? ChangeType(object? value, Type expectedType)
	{
		return TypeConverter.ChangeType(value, expectedType);
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.Utilities.ReflectionUtility ----
namespace YamlDotNet.Serialization.Utilities
{
internal static class ReflectionUtility
{
	public static Type? GetImplementedGenericInterface(Type type, Type genericInterfaceType)
	{
		foreach (Type implementedInterface in GetImplementedInterfaces(type))
		{
			if (implementedInterface.IsGenericType() && implementedInterface.GetGenericTypeDefinition() == genericInterfaceType)
			{
				return implementedInterface;
			}
		}
		return null;
	}

	public static IEnumerable<Type> GetImplementedInterfaces(Type type)
	{
		if (type.IsInterface())
		{
			yield return type;
		}
		Type[] interfaces = type.GetInterfaces();
		for (int i = 0; i < interfaces.Length; i++)
		{
			yield return interfaces[i];
		}
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.Utilities.SerializerState ----
namespace YamlDotNet.Serialization.Utilities
{
internal sealed class SerializerState : IDisposable
{
	private readonly IDictionary<Type, object> items = new Dictionary<Type, object>();

	public T Get<T>() where T : class, new()
	{
		if (!items.TryGetValue(typeof(T), out object value))
		{
			value = new T();
			items.Add(typeof(T), value);
		}
		return (T)value;
	}

	public void OnDeserialization()
	{
		foreach (IPostDeserializationCallback item in items.Values.OfType<IPostDeserializationCallback>())
		{
			item.OnDeserialization();
		}
	}

	public void Dispose()
	{
		foreach (IDisposable item in items.Values.OfType<IDisposable>())
		{
			item.Dispose();
		}
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.Utilities.StringExtensions ----
namespace YamlDotNet.Serialization.Utilities
{
internal static class StringExtensions
{
	private static string ToCamelOrPascalCase(string str, Func<char, char> firstLetterTransform)
	{
		string text = Regex.Replace(str, "([_\\-])(?<char>[a-z])", (Match match) => match.Groups["char"].Value.ToUpperInvariant(), RegexOptions.IgnoreCase);
		return firstLetterTransform(text[0]) + text.Substring(1);
	}

	public static string ToCamelCase(this string str)
	{
		return ToCamelOrPascalCase(str, char.ToLowerInvariant);
	}

	public static string ToPascalCase(this string str)
	{
		return ToCamelOrPascalCase(str, char.ToUpperInvariant);
	}

	public static string FromCamelCase(this string str, string separator)
	{
		str = char.ToLower(str[0]) + str.Substring(1);
		str = Regex.Replace(str.ToCamelCase(), "(?<char>[A-Z])", (Match match) => separator + match.Groups["char"].Value.ToLowerInvariant());
		return str;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.Utilities.TypeConverter ----
namespace YamlDotNet.Serialization.Utilities
{
internal static class TypeConverter
{
	public static T ChangeType<T>(object? value)
	{
		return (T)ChangeType(value, typeof(T));
	}

	public static T ChangeType<T>(object? value, IFormatProvider provider)
	{
		return (T)ChangeType(value, typeof(T), provider);
	}

	public static T ChangeType<T>(object? value, CultureInfo culture)
	{
		return (T)ChangeType(value, typeof(T), culture);
	}

	public static object? ChangeType(object? value, Type destinationType)
	{
		return ChangeType(value, destinationType, CultureInfo.InvariantCulture);
	}

	public static object? ChangeType(object? value, Type destinationType, IFormatProvider provider)
	{
		return ChangeType(value, destinationType, new CultureInfoAdapter(CultureInfo.CurrentCulture, provider));
	}

	public static object? ChangeType(object? value, Type destinationType, CultureInfo culture)
	{
		if (value == null || value.IsDbNull())
		{
			if (!destinationType.IsValueType())
			{
				return null;
			}
			return Activator.CreateInstance(destinationType);
		}
		Type type = value.GetType();
		if (destinationType == type || destinationType.IsAssignableFrom(type))
		{
			return value;
		}
		if (destinationType.IsGenericType() && destinationType.GetGenericTypeDefinition() == typeof(Nullable<>))
		{
			Type destinationType2 = destinationType.GetGenericArguments()[0];
			object obj = ChangeType(value, destinationType2, culture);
			return Activator.CreateInstance(destinationType, obj);
		}
		if (destinationType.IsEnum())
		{
			if (!(value is string value2))
			{
				return value;
			}
			return Enum.Parse(destinationType, value2, ignoreCase: true);
		}
		if (destinationType == typeof(bool))
		{
			if ("0".Equals(value))
			{
				return false;
			}
			if ("1".Equals(value))
			{
				return true;
			}
		}
		System.ComponentModel.TypeConverter converter = TypeDescriptor.GetConverter(type);
		if (converter != null && converter.CanConvertTo(destinationType))
		{
			return converter.ConvertTo(null, culture, value, destinationType);
		}
		System.ComponentModel.TypeConverter converter2 = TypeDescriptor.GetConverter(destinationType);
		if (converter2 != null && converter2.CanConvertFrom(type))
		{
			return converter2.ConvertFrom(null, culture, value);
		}
		Type[] array = new Type[2] { type, destinationType };
		for (int i = 0; i < array.Length; i++)
		{
			foreach (MethodInfo publicStaticMethod2 in array[i].GetPublicStaticMethods())
			{
				if (!publicStaticMethod2.IsSpecialName || (!(publicStaticMethod2.Name == "op_Implicit") && !(publicStaticMethod2.Name == "op_Explicit")) || !destinationType.IsAssignableFrom(publicStaticMethod2.ReturnParameter.ParameterType))
				{
					continue;
				}
				ParameterInfo[] parameters = publicStaticMethod2.GetParameters();
				if (parameters.Length == 1 && parameters[0].ParameterType.IsAssignableFrom(type))
				{
					try
					{
						return publicStaticMethod2.Invoke(null, new object[1] { value });
					}
					catch (TargetInvocationException ex)
					{
						throw ex.Unwrap();
					}
				}
			}
		}
		if (type == typeof(string))
		{
			try
			{
				MethodInfo publicStaticMethod = destinationType.GetPublicStaticMethod("Parse", typeof(string), typeof(IFormatProvider));
				if (publicStaticMethod != null)
				{
					return publicStaticMethod.Invoke(null, new object[2] { value, culture });
				}
				publicStaticMethod = destinationType.GetPublicStaticMethod("Parse", typeof(string));
				if (publicStaticMethod != null)
				{
					return publicStaticMethod.Invoke(null, new object[1] { value });
				}
			}
			catch (TargetInvocationException ex2)
			{
				throw ex2.Unwrap();
			}
		}
		if (destinationType == typeof(TimeSpan))
		{
			return TimeSpan.Parse((string)ChangeType(value, typeof(string), CultureInfo.InvariantCulture));
		}
		return Convert.ChangeType(value, destinationType, CultureInfo.InvariantCulture);
	}

	public static void RegisterTypeConverter<TConvertible, TConverter>() where TConverter : System.ComponentModel.TypeConverter
	{
		if (!TypeDescriptor.GetAttributes(typeof(TConvertible)).OfType<TypeConverterAttribute>().Any((TypeConverterAttribute a) => a.ConverterTypeName == typeof(TConverter).AssemblyQualifiedName))
		{
			TypeDescriptor.AddAttributes(typeof(TConvertible), new TypeConverterAttribute(typeof(TConverter)));
		}
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.TypeResolvers.DynamicTypeResolver ----
namespace YamlDotNet.Serialization.TypeResolvers
{
internal sealed class DynamicTypeResolver : ITypeResolver
{
	public Type Resolve(Type staticType, object? actualValue)
	{
		if (actualValue == null)
		{
			return staticType;
		}
		return actualValue.GetType();
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.TypeResolvers.StaticTypeResolver ----
namespace YamlDotNet.Serialization.TypeResolvers
{
internal sealed class StaticTypeResolver : ITypeResolver
{
	public Type Resolve(Type staticType, object? actualValue)
	{
		return staticType;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.TypeInspectors.CachedTypeInspector ----
namespace YamlDotNet.Serialization.TypeInspectors
{
internal sealed class CachedTypeInspector : TypeInspectorSkeleton
{
	private readonly ITypeInspector innerTypeDescriptor;

	private readonly ConcurrentDictionary<Type, List<IPropertyDescriptor>> cache = new ConcurrentDictionary<Type, List<IPropertyDescriptor>>();

	public CachedTypeInspector(ITypeInspector innerTypeDescriptor)
	{
		this.innerTypeDescriptor = innerTypeDescriptor ?? throw new ArgumentNullException("innerTypeDescriptor");
	}

	public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
	{
		return cache.GetOrAdd(type, (Type t) => innerTypeDescriptor.GetProperties(t, container).ToList());
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.TypeInspectors.CompositeTypeInspector ----
namespace YamlDotNet.Serialization.TypeInspectors
{
internal sealed class CompositeTypeInspector : TypeInspectorSkeleton
{
	private readonly IEnumerable<ITypeInspector> typeInspectors;

	public CompositeTypeInspector(params ITypeInspector[] typeInspectors)
		: this((IEnumerable<ITypeInspector>)typeInspectors)
	{
	}

	public CompositeTypeInspector(IEnumerable<ITypeInspector> typeInspectors)
	{
		this.typeInspectors = typeInspectors?.ToList() ?? throw new ArgumentNullException("typeInspectors");
	}

	public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
	{
		return typeInspectors.SelectMany((ITypeInspector i) => i.GetProperties(type, container));
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.TypeInspectors.NamingConventionTypeInspector ----
namespace YamlDotNet.Serialization.TypeInspectors
{
internal sealed class NamingConventionTypeInspector : TypeInspectorSkeleton
{
	private readonly ITypeInspector innerTypeDescriptor;

	private readonly INamingConvention namingConvention;

	public NamingConventionTypeInspector(ITypeInspector innerTypeDescriptor, INamingConvention namingConvention)
	{
		this.innerTypeDescriptor = innerTypeDescriptor ?? throw new ArgumentNullException("innerTypeDescriptor");
		this.namingConvention = namingConvention ?? throw new ArgumentNullException("namingConvention");
	}

	public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
	{
		return innerTypeDescriptor.GetProperties(type, container).Select(delegate(IPropertyDescriptor p)
		{
			YamlMemberAttribute customAttribute = p.GetCustomAttribute<YamlMemberAttribute>();
			return (customAttribute != null && !customAttribute.ApplyNamingConventions) ? p : new PropertyDescriptor(p)
			{
				Name = namingConvention.Apply(p.Name)
			};
		});
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.TypeInspectors.ReadableAndWritablePropertiesTypeInspector ----
namespace YamlDotNet.Serialization.TypeInspectors
{
internal sealed class ReadableAndWritablePropertiesTypeInspector : TypeInspectorSkeleton
{
	private readonly ITypeInspector innerTypeDescriptor;

	public ReadableAndWritablePropertiesTypeInspector(ITypeInspector innerTypeDescriptor)
	{
		this.innerTypeDescriptor = innerTypeDescriptor ?? throw new ArgumentNullException("innerTypeDescriptor");
	}

	public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
	{
		return from p in innerTypeDescriptor.GetProperties(type, container)
			where p.CanWrite
			select p;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.TypeInspectors.ReadableFieldsTypeInspector ----
namespace YamlDotNet.Serialization.TypeInspectors
{
internal sealed class ReadableFieldsTypeInspector : TypeInspectorSkeleton
{
	private sealed class ReflectionFieldDescriptor : IPropertyDescriptor
	{
		private readonly FieldInfo fieldInfo;

		private readonly ITypeResolver typeResolver;

		public string Name => fieldInfo.Name;

		public Type Type => fieldInfo.FieldType;

		public Type? TypeOverride { get; set; }

		public int Order { get; set; }

		public bool CanWrite => !fieldInfo.IsInitOnly;

		public ScalarStyle ScalarStyle { get; set; }

		public ReflectionFieldDescriptor(FieldInfo fieldInfo, ITypeResolver typeResolver)
		{
			this.fieldInfo = fieldInfo;
			this.typeResolver = typeResolver;
			ScalarStyle = ScalarStyle.Any;
		}

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

		public T? GetCustomAttribute<T>() where T : Attribute
		{
			return (T)fieldInfo.GetCustomAttributes(typeof(T), inherit: true).FirstOrDefault();
		}

		public IObjectDescriptor Read(object target)
		{
			object value = fieldInfo.GetValue(target);
			Type type = TypeOverride ?? typeResolver.Resolve(Type, value);
			return new ObjectDescriptor(value, type, Type, ScalarStyle);
		}
	}

	private readonly ITypeResolver typeResolver;

	public ReadableFieldsTypeInspector(ITypeResolver typeResolver)
	{
		this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
	}

	public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
	{
		return type.GetPublicFields().Select<FieldInfo, IPropertyDescriptor>((Func<FieldInfo, IPropertyDescriptor>)((FieldInfo p) => new ReflectionFieldDescriptor(p, typeResolver)));
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.TypeInspectors.ReadablePropertiesTypeInspector ----
namespace YamlDotNet.Serialization.TypeInspectors
{
internal sealed class ReadablePropertiesTypeInspector : TypeInspectorSkeleton
{
	private sealed class ReflectionPropertyDescriptor : IPropertyDescriptor
	{
		private readonly PropertyInfo propertyInfo;

		private readonly ITypeResolver typeResolver;

		public string Name => propertyInfo.Name;

		public Type Type => propertyInfo.PropertyType;

		public Type? TypeOverride { get; set; }

		public int Order { get; set; }

		public bool CanWrite => propertyInfo.CanWrite;

		public ScalarStyle ScalarStyle { get; set; }

		public ReflectionPropertyDescriptor(PropertyInfo propertyInfo, ITypeResolver typeResolver)
		{
			this.propertyInfo = propertyInfo ?? throw new ArgumentNullException("propertyInfo");
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			ScalarStyle = ScalarStyle.Any;
		}

		public void Write(object target, object? value)
		{
			propertyInfo.SetValue(target, value, null);
		}

		public T? GetCustomAttribute<T>() where T : Attribute
		{
			return (T)propertyInfo.GetAllCustomAttributes<T>().FirstOrDefault();
		}

		public IObjectDescriptor Read(object target)
		{
			object obj = propertyInfo.ReadValue(target);
			Type type = TypeOverride ?? typeResolver.Resolve(Type, obj);
			return new ObjectDescriptor(obj, type, Type, ScalarStyle);
		}
	}

	private readonly ITypeResolver typeResolver;

	private readonly bool includeNonPublicProperties;

	public ReadablePropertiesTypeInspector(ITypeResolver typeResolver)
		: this(typeResolver, includeNonPublicProperties: false)
	{
	}

	public ReadablePropertiesTypeInspector(ITypeResolver typeResolver, bool includeNonPublicProperties)
	{
		this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
		this.includeNonPublicProperties = includeNonPublicProperties;
	}

	private static bool IsValidProperty(PropertyInfo property)
	{
		if (property.CanRead)
		{
			return property.GetGetMethod(nonPublic: true).GetParameters().Length == 0;
		}
		return false;
	}

	public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
	{
		return type.GetProperties(includeNonPublicProperties).Where(IsValidProperty).Select<PropertyInfo, IPropertyDescriptor>((Func<PropertyInfo, IPropertyDescriptor>)((PropertyInfo p) => new ReflectionPropertyDescriptor(p, typeResolver)));
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.TypeInspectors.TypeInspectorSkeleton ----
namespace YamlDotNet.Serialization.TypeInspectors
{
internal abstract class TypeInspectorSkeleton : ITypeInspector
{
	public abstract IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container);

	public IPropertyDescriptor GetProperty(Type type, object? container, string name, [MaybeNullWhen(true)] bool ignoreUnmatched)
	{
		IEnumerable<IPropertyDescriptor> enumerable = from p in GetProperties(type, container)
			where p.Name == name
			select p;
		using IEnumerator<IPropertyDescriptor> enumerator = enumerable.GetEnumerator();
		if (!enumerator.MoveNext())
		{
			if (ignoreUnmatched)
			{
				return null;
			}
			throw new SerializationException("Property '" + name + "' not found on type '" + type.FullName + "'.");
		}
		IPropertyDescriptor current = enumerator.Current;
		if (enumerator.MoveNext())
		{
			throw new SerializationException("Multiple properties with the name/alias '" + name + "' already exists on type '" + type.FullName + "', maybe you're misusing YamlAlias or maybe you are using the wrong naming convention? The matching properties are: " + string.Join(", ", enumerable.Select((IPropertyDescriptor p) => p.Name).ToArray()));
		}
		return current;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.TypeInspectors.WritablePropertiesTypeInspector ----
namespace YamlDotNet.Serialization.TypeInspectors
{
internal sealed class WritablePropertiesTypeInspector : TypeInspectorSkeleton
{
	private sealed class ReflectionPropertyDescriptor : IPropertyDescriptor
	{
		private readonly PropertyInfo propertyInfo;

		private readonly ITypeResolver typeResolver;

		public string Name => propertyInfo.Name;

		public Type Type => propertyInfo.PropertyType;

		public Type? TypeOverride { get; set; }

		public int Order { get; set; }

		public bool CanWrite => propertyInfo.CanWrite;

		public ScalarStyle ScalarStyle { get; set; }

		public ReflectionPropertyDescriptor(PropertyInfo propertyInfo, ITypeResolver typeResolver)
		{
			this.propertyInfo = propertyInfo ?? throw new ArgumentNullException("propertyInfo");
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			ScalarStyle = ScalarStyle.Any;
		}

		public void Write(object target, object? value)
		{
			propertyInfo.SetValue(target, value, null);
		}

		public T? GetCustomAttribute<T>() where T : Attribute
		{
			return (T)propertyInfo.GetAllCustomAttributes<T>().FirstOrDefault();
		}

		public IObjectDescriptor Read(object target)
		{
			object obj = propertyInfo.ReadValue(target);
			Type type = TypeOverride ?? typeResolver.Resolve(Type, obj);
			return new ObjectDescriptor(obj, type, Type, ScalarStyle);
		}
	}

	private readonly ITypeResolver typeResolver;

	private readonly bool includeNonPublicProperties;

	public WritablePropertiesTypeInspector(ITypeResolver typeResolver)
		: this(typeResolver, includeNonPublicProperties: false)
	{
	}

	public WritablePropertiesTypeInspector(ITypeResolver typeResolver, bool includeNonPublicProperties)
	{
		this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
		this.includeNonPublicProperties = includeNonPublicProperties;
	}

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

	public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
	{
		return type.GetProperties(includeNonPublicProperties).Where(IsValidProperty).Select<PropertyInfo, IPropertyDescriptor>((Func<PropertyInfo, IPropertyDescriptor>)((PropertyInfo p) => new ReflectionPropertyDescriptor(p, typeResolver)))
			.ToArray();
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.Schemas.FailsafeSchema ----
namespace YamlDotNet.Serialization.Schemas
{
internal sealed class FailsafeSchema
{
	public static class Tags
	{
		public static readonly TagName Map = new TagName("tag:yaml.org,2002:map");

		public static readonly TagName Seq = new TagName("tag:yaml.org,2002:seq");

		public static readonly TagName Str = new TagName("tag:yaml.org,2002:str");
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.Schemas.JsonSchema ----
namespace YamlDotNet.Serialization.Schemas
{
internal sealed class JsonSchema
{
	public static class Tags
	{
		public static readonly TagName Null = new TagName("tag:yaml.org,2002:null");

		public static readonly TagName Bool = new TagName("tag:yaml.org,2002:bool");

		public static readonly TagName Int = new TagName("tag:yaml.org,2002:int");

		public static readonly TagName Float = new TagName("tag:yaml.org,2002:float");
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.Schemas.CoreSchema ----
namespace YamlDotNet.Serialization.Schemas
{
internal sealed class CoreSchema
{
	public static class Tags
	{
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.Schemas.DefaultSchema ----
namespace YamlDotNet.Serialization.Schemas
{
internal sealed class DefaultSchema
{
	public static class Tags
	{
		public static readonly TagName Timestamp = new TagName("tag:yaml.org,2002:timestamp");
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.ObjectGraphVisitors.AnchorAssigner ----
namespace YamlDotNet.Serialization.ObjectGraphVisitors
{
internal sealed class AnchorAssigner(IEnumerable<IYamlTypeConverter> typeConverters) : PreProcessingPhaseObjectGraphVisitorSkeleton(typeConverters), IAliasProvider
{
	private class AnchorAssignment
	{
		public AnchorName Anchor;
	}

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

	private uint nextId;

	protected override bool Enter(IObjectDescriptor value)
	{
		if (value.Value != null && assignments.TryGetValue(value.Value, out AnchorAssignment value2))
		{
			if (value2.Anchor.IsEmpty)
			{
				value2.Anchor = new AnchorName("o" + nextId.ToString(CultureInfo.InvariantCulture));
				nextId++;
			}
			return false;
		}
		return true;
	}

	protected override bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value)
	{
		return true;
	}

	protected override bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value)
	{
		return true;
	}

	protected override void VisitScalar(IObjectDescriptor scalar)
	{
	}

	protected override void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType)
	{
		VisitObject(mapping);
	}

	protected override void VisitMappingEnd(IObjectDescriptor mapping)
	{
	}

	protected override void VisitSequenceStart(IObjectDescriptor sequence, Type elementType)
	{
		VisitObject(sequence);
	}

	protected override void VisitSequenceEnd(IObjectDescriptor sequence)
	{
	}

	private void VisitObject(IObjectDescriptor value)
	{
		if (value.Value != null)
		{
			assignments.Add(value.Value, new AnchorAssignment());
		}
	}

	AnchorName IAliasProvider.GetAlias(object target)
	{
		if (target != null && assignments.TryGetValue(target, out AnchorAssignment value))
		{
			return value.Anchor;
		}
		return AnchorName.Empty;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.ObjectGraphVisitors.AnchorAssigningObjectGraphVisitor ----
namespace YamlDotNet.Serialization.ObjectGraphVisitors
{
internal sealed class AnchorAssigningObjectGraphVisitor : ChainedObjectGraphVisitor
{
	private readonly IEventEmitter eventEmitter;

	private readonly IAliasProvider aliasProvider;

	private readonly HashSet<AnchorName> emittedAliases = new HashSet<AnchorName>();

	public AnchorAssigningObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor, IEventEmitter eventEmitter, IAliasProvider aliasProvider)
		: base(nextVisitor)
	{
		this.eventEmitter = eventEmitter;
		this.aliasProvider = aliasProvider;
	}

	public override bool Enter(IObjectDescriptor value, IEmitter context)
	{
		if (value.Value != null)
		{
			AnchorName alias = aliasProvider.GetAlias(value.Value);
			if (!alias.IsEmpty && !emittedAliases.Add(alias))
			{
				AliasEventInfo aliasEventInfo = new AliasEventInfo(value, alias);
				eventEmitter.Emit(aliasEventInfo, context);
				return aliasEventInfo.NeedsExpansion;
			}
		}
		return base.Enter(value, context);
	}

	public override void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, IEmitter context)
	{
		AnchorName alias = aliasProvider.GetAlias(mapping.NonNullValue());
		eventEmitter.Emit(new MappingStartEventInfo(mapping)
		{
			Anchor = alias
		}, context);
	}

	public override void VisitSequenceStart(IObjectDescriptor sequence, Type elementType, IEmitter context)
	{
		AnchorName alias = aliasProvider.GetAlias(sequence.NonNullValue());
		eventEmitter.Emit(new SequenceStartEventInfo(sequence)
		{
			Anchor = alias
		}, context);
	}

	public override void VisitScalar(IObjectDescriptor scalar, IEmitter context)
	{
		ScalarEventInfo scalarEventInfo = new ScalarEventInfo(scalar);
		if (scalar.Value != null)
		{
			scalarEventInfo.Anchor = aliasProvider.GetAlias(scalar.Value);
		}
		eventEmitter.Emit(scalarEventInfo, context);
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.ObjectGraphVisitors.ChainedObjectGraphVisitor ----
namespace YamlDotNet.Serialization.ObjectGraphVisitors
{
internal abstract class ChainedObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
{
	private readonly IObjectGraphVisitor<IEmitter> nextVisitor;

	protected ChainedObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor)
	{
		this.nextVisitor = nextVisitor;
	}

	public virtual bool Enter(IObjectDescriptor value, IEmitter context)
	{
		return nextVisitor.Enter(value, context);
	}

	public virtual bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value, IEmitter context)
	{
		return nextVisitor.EnterMapping(key, value, context);
	}

	public virtual bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context)
	{
		return nextVisitor.EnterMapping(key, value, context);
	}

	public virtual void VisitScalar(IObjectDescriptor scalar, IEmitter context)
	{
		nextVisitor.VisitScalar(scalar, context);
	}

	public virtual void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, IEmitter context)
	{
		nextVisitor.VisitMappingStart(mapping, keyType, valueType, context);
	}

	public virtual void VisitMappingEnd(IObjectDescriptor mapping, IEmitter context)
	{
		nextVisitor.VisitMappingEnd(mapping, context);
	}

	public virtual void VisitSequenceStart(IObjectDescriptor sequence, Type elementType, IEmitter context)
	{
		nextVisitor.VisitSequenceStart(sequence, elementType, context);
	}

	public virtual void VisitSequenceEnd(IObjectDescriptor sequence, IEmitter context)
	{
		nextVisitor.VisitSequenceEnd(sequence, context);
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.ObjectGraphVisitors.CommentsObjectGraphVisitor ----
namespace YamlDotNet.Serialization.ObjectGraphVisitors
{
internal sealed class CommentsObjectGraphVisitor : ChainedObjectGraphVisitor
{
	public CommentsObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor)
		: base(nextVisitor)
	{
	}

	public override bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context)
	{
		YamlMemberAttribute customAttribute = key.GetCustomAttribute<YamlMemberAttribute>();
		if (customAttribute != null && customAttribute.Description != null)
		{
			context.Emit(new Comment(customAttribute.Description, isInline: false));
		}
		return base.EnterMapping(key, value, context);
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.ObjectGraphVisitors.CustomSerializationObjectGraphVisitor ----
namespace YamlDotNet.Serialization.ObjectGraphVisitors
{
internal sealed class CustomSerializationObjectGraphVisitor : ChainedObjectGraphVisitor
{
	private readonly IEnumerable<IYamlTypeConverter> typeConverters;

	private readonly ObjectSerializer nestedObjectSerializer;

	public CustomSerializationObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor, IEnumerable<IYamlTypeConverter> typeConverters, ObjectSerializer nestedObjectSerializer)
		: base(nextVisitor)
	{
		IEnumerable<IYamlTypeConverter> enumerable;
		if (typeConverters == null)
		{
			enumerable = Enumerable.Empty<IYamlTypeConverter>();
		}
		else
		{
			IEnumerable<IYamlTypeConverter> enumerable2 = typeConverters.ToList();
			enumerable = enumerable2;
		}
		this.typeConverters = enumerable;
		this.nestedObjectSerializer = nestedObjectSerializer;
	}

	public override bool Enter(IObjectDescriptor value, IEmitter context)
	{
		IYamlTypeConverter yamlTypeConverter = typeConverters.FirstOrDefault((IYamlTypeConverter t) => t.Accepts(value.Type));
		if (yamlTypeConverter != null)
		{
			yamlTypeConverter.WriteYaml(context, value.Value, value.Type);
			return false;
		}
		if (value.Value is IYamlConvertible yamlConvertible)
		{
			yamlConvertible.Write(context, nestedObjectSerializer);
			return false;
		}
		if (value.Value is IYamlSerializable yamlSerializable)
		{
			yamlSerializable.WriteYaml(context);
			return false;
		}
		return base.Enter(value, context);
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.ObjectGraphVisitors.DefaultExclusiveObjectGraphVisitor ----
namespace YamlDotNet.Serialization.ObjectGraphVisitors
{
internal sealed class DefaultExclusiveObjectGraphVisitor : ChainedObjectGraphVisitor
{
	public DefaultExclusiveObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor)
		: base(nextVisitor)
	{
	}

	private static object? GetDefault(Type type)
	{
		if (!type.IsValueType())
		{
			return null;
		}
		return Activator.CreateInstance(type);
	}

	public override bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value, IEmitter context)
	{
		if (!object.Equals(value.Value, GetDefault(value.Type)))
		{
			return base.EnterMapping(key, value, context);
		}
		return false;
	}

	public override bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context)
	{
		DefaultValueAttribute customAttribute = key.GetCustomAttribute<DefaultValueAttribute>();
		object objB = ((customAttribute != null) ? customAttribute.Value : GetDefault(key.Type));
		if (!object.Equals(value.Value, objB))
		{
			return base.EnterMapping(key, value, context);
		}
		return false;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.ObjectGraphVisitors.DefaultValuesObjectGraphVisitor ----
namespace YamlDotNet.Serialization.ObjectGraphVisitors
{
internal sealed class DefaultValuesObjectGraphVisitor : ChainedObjectGraphVisitor
{
	private readonly DefaultValuesHandling handling;

	private readonly IObjectFactory factory;

	public DefaultValuesObjectGraphVisitor(DefaultValuesHandling handling, IObjectGraphVisitor<IEmitter> nextVisitor, IObjectFactory factory)
		: base(nextVisitor)
	{
		this.handling = handling;
		this.factory = factory;
	}

	private object? GetDefault(Type type)
	{
		return factory.CreatePrimitive(type);
	}

	public override bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context)
	{
		DefaultValuesHandling defaultValuesHandling = handling;
		YamlMemberAttribute customAttribute = key.GetCustomAttribute<YamlMemberAttribute>();
		if (customAttribute != null && customAttribute.IsDefaultValuesHandlingSpecified)
		{
			defaultValuesHandling = customAttribute.DefaultValuesHandling;
		}
		if ((defaultValuesHandling & DefaultValuesHandling.OmitNull) != DefaultValuesHandling.Preserve && value.Value == null)
		{
			return false;
		}
		if ((defaultValuesHandling & DefaultValuesHandling.OmitEmptyCollections) != DefaultValuesHandling.Preserve && value.Value is IEnumerable enumerable)
		{
			IEnumerator enumerator = enumerable.GetEnumerator();
			bool flag = enumerator.MoveNext();
			if (enumerator is IDisposable disposable)
			{
				disposable.Dispose();
			}
			if (!flag)
			{
				return false;
			}
		}
		if ((defaultValuesHandling & DefaultValuesHandling.OmitDefaults) != DefaultValuesHandling.Preserve)
		{
			object objB = key.GetCustomAttribute<DefaultValueAttribute>()?.Value ?? GetDefault(key.Type);
			if (object.Equals(value.Value, objB))
			{
				return false;
			}
		}
		return base.EnterMapping(key, value, context);
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.ObjectGraphVisitors.EmittingObjectGraphVisitor ----
namespace YamlDotNet.Serialization.ObjectGraphVisitors
{
internal sealed class EmittingObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
{
	private readonly IEventEmitter eventEmitter;

	public EmittingObjectGraphVisitor(IEventEmitter eventEmitter)
	{
		this.eventEmitter = eventEmitter;
	}

	bool IObjectGraphVisitor<IEmitter>.Enter(IObjectDescriptor value, IEmitter context)
	{
		return true;
	}

	bool IObjectGraphVisitor<IEmitter>.EnterMapping(IObjectDescriptor key, IObjectDescriptor value, IEmitter context)
	{
		return true;
	}

	bool IObjectGraphVisitor<IEmitter>.EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context)
	{
		return true;
	}

	void IObjectGraphVisitor<IEmitter>.VisitScalar(IObjectDescriptor scalar, IEmitter context)
	{
		eventEmitter.Emit(new ScalarEventInfo(scalar), context);
	}

	void IObjectGraphVisitor<IEmitter>.VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, IEmitter context)
	{
		eventEmitter.Emit(new MappingStartEventInfo(mapping), context);
	}

	void IObjectGraphVisitor<IEmitter>.VisitMappingEnd(IObjectDescriptor mapping, IEmitter context)
	{
		eventEmitter.Emit(new MappingEndEventInfo(mapping), context);
	}

	void IObjectGraphVisitor<IEmitter>.VisitSequenceStart(IObjectDescriptor sequence, Type elementType, IEmitter context)
	{
		eventEmitter.Emit(new SequenceStartEventInfo(sequence), context);
	}

	void IObjectGraphVisitor<IEmitter>.VisitSequenceEnd(IObjectDescriptor sequence, IEmitter context)
	{
		eventEmitter.Emit(new SequenceEndEventInfo(sequence), context);
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.ObjectGraphVisitors.PreProcessingPhaseObjectGraphVisitorSkeleton ----
namespace YamlDotNet.Serialization.ObjectGraphVisitors
{
internal abstract class PreProcessingPhaseObjectGraphVisitorSkeleton : IObjectGraphVisitor<Nothing>
{
	protected readonly IEnumerable<IYamlTypeConverter> typeConverters;

	public PreProcessingPhaseObjectGraphVisitorSkeleton(IEnumerable<IYamlTypeConverter> typeConverters)
	{
		IEnumerable<IYamlTypeConverter> enumerable;
		if (typeConverters == null)
		{
			enumerable = Enumerable.Empty<IYamlTypeConverter>();
		}
		else
		{
			IEnumerable<IYamlTypeConverter> enumerable2 = typeConverters.ToList();
			enumerable = enumerable2;
		}
		this.typeConverters = enumerable;
	}

	bool IObjectGraphVisitor<Nothing>.Enter(IObjectDescriptor value, Nothing context)
	{
		if (typeConverters.FirstOrDefault((IYamlTypeConverter t) => t.Accepts(value.Type)) != null)
		{
			return false;
		}
		if (value.Value is IYamlConvertible)
		{
			return false;
		}
		if (value.Value is IYamlSerializable)
		{
			return false;
		}
		return Enter(value);
	}

	bool IObjectGraphVisitor<Nothing>.EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, Nothing context)
	{
		return EnterMapping(key, value);
	}

	bool IObjectGraphVisitor<Nothing>.EnterMapping(IObjectDescriptor key, IObjectDescriptor value, Nothing context)
	{
		return EnterMapping(key, value);
	}

	void IObjectGraphVisitor<Nothing>.VisitMappingEnd(IObjectDescriptor mapping, Nothing context)
	{
		VisitMappingEnd(mapping);
	}

	void IObjectGraphVisitor<Nothing>.VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, Nothing context)
	{
		VisitMappingStart(mapping, keyType, valueType);
	}

	void IObjectGraphVisitor<Nothing>.VisitScalar(IObjectDescriptor scalar, Nothing context)
	{
		VisitScalar(scalar);
	}

	void IObjectGraphVisitor<Nothing>.VisitSequenceEnd(IObjectDescriptor sequence, Nothing context)
	{
		VisitSequenceEnd(sequence);
	}

	void IObjectGraphVisitor<Nothing>.VisitSequenceStart(IObjectDescriptor sequence, Type elementType, Nothing context)
	{
		VisitSequenceStart(sequence, elementType);
	}

	protected abstract bool Enter(IObjectDescriptor value);

	protected abstract bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value);

	protected abstract bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value);

	protected abstract void VisitMappingEnd(IObjectDescriptor mapping);

	protected abstract void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType);

	protected abstract void VisitScalar(IObjectDescriptor scalar);

	protected abstract void VisitSequenceEnd(IObjectDescriptor sequence);

	protected abstract void VisitSequenceStart(IObjectDescriptor sequence, Type elementType);
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.ObjectGraphTraversalStrategies.FullObjectGraphTraversalStrategy ----
namespace YamlDotNet.Serialization.ObjectGraphTraversalStrategies
{
internal class FullObjectGraphTraversalStrategy : IObjectGraphTraversalStrategy
{
	protected struct ObjectPathSegment(object name, IObjectDescriptor value)
	{
		public readonly object Name = name;

		public readonly IObjectDescriptor Value = value;
	}

	private readonly int maxRecursion;

	private readonly ITypeInspector typeDescriptor;

	private readonly ITypeResolver typeResolver;

	private readonly INamingConvention namingConvention;

	private readonly IObjectFactory objectFactory;

	public FullObjectGraphTraversalStrategy(ITypeInspector typeDescriptor, ITypeResolver typeResolver, int maxRecursion, INamingConvention namingConvention, IObjectFactory objectFactory)
	{
		if (maxRecursion <= 0)
		{
			throw new ArgumentOutOfRangeException("maxRecursion", maxRecursion, "maxRecursion must be greater than 1");
		}
		this.typeDescriptor = typeDescriptor ?? throw new ArgumentNullException("typeDescriptor");
		this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
		this.maxRecursion = maxRecursion;
		this.namingConvention = namingConvention ?? throw new ArgumentNullException("namingConvention");
		this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
	}

	void IObjectGraphTraversalStrategy.Traverse<TContext>(IObjectDescriptor graph, IObjectGraphVisitor<TContext> visitor, TContext context)
	{
		Traverse("<root>", graph, visitor, context, new Stack<ObjectPathSegment>(maxRecursion));
	}

	protected virtual void Traverse<TContext>(object name, IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path)
	{
		if (path.Count >= maxRecursion)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("Too much recursion when traversing the object graph.");
			stringBuilder.AppendLine("The path to reach this recursion was:");
			Stack<KeyValuePair<string, string>> stack = new Stack<KeyValuePair<string, string>>(path.Count);
			int num = 0;
			foreach (ObjectPathSegment item in path)
			{
				string text = item.Name?.ToString() ?? string.Empty;
				num = Math.Max(num, text.Length);
				stack.Push(new KeyValuePair<string, string>(text, item.Value.Type.FullName));
			}
			foreach (KeyValuePair<string, string> item2 in stack)
			{
				stringBuilder.Append(" -> ").Append(item2.Key.PadRight(num)).Append("  [")
					.Append(item2.Value)
					.AppendLine("]");
			}
			throw new MaximumRecursionLevelReachedException(stringBuilder.ToString());
		}
		if (!visitor.Enter(value, context))
		{
			return;
		}
		path.Push(new ObjectPathSegment(name, value));
		try
		{
			TypeCode typeCode = value.Type.GetTypeCode();
			switch (typeCode)
			{
			case TypeCode.Boolean:
			case TypeCode.Char:
			case TypeCode.SByte:
			case TypeCode.Byte:
			case TypeCode.Int16:
			case TypeCode.UInt16:
			case TypeCode.Int32:
			case TypeCode.UInt32:
			case TypeCode.Int64:
			case TypeCode.UInt64:
			case TypeCode.Single:
			case TypeCode.Double:
			case TypeCode.Decimal:
			case TypeCode.DateTime:
			case TypeCode.String:
				visitor.VisitScalar(value, context);
				return;
			case TypeCode.Empty:
				throw new NotSupportedException($"TypeCode.{typeCode} is not supported.");
			}
			if (value.IsDbNull())
			{
				visitor.VisitScalar(new ObjectDescriptor(null, typeof(object), typeof(object)), context);
			}
			if (value.Value == null || value.Type == typeof(TimeSpan))
			{
				visitor.VisitScalar(value, context);
				return;
			}
			Type underlyingType = Nullable.GetUnderlyingType(value.Type);
			if (underlyingType != null)
			{
				Traverse("Value", new ObjectDescriptor(value.Value, underlyingType, value.Type, value.ScalarStyle), visitor, context, path);
			}
			else
			{
				TraverseObject(value, visitor, context, path);
			}
		}
		finally
		{
			path.Pop();
		}
	}

	protected virtual void TraverseObject<TContext>(IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path)
	{
		IDictionary dictionary;
		Type[] genericArguments;
		if (typeof(IDictionary).IsAssignableFrom(value.Type))
		{
			TraverseDictionary(value, visitor, typeof(object), typeof(object), context, path);
		}
		else if (objectFactory.GetDictionary(value, out dictionary, out genericArguments))
		{
			TraverseDictionary(new ObjectDescriptor(dictionary, value.Type, value.StaticType, value.ScalarStyle), visitor, genericArguments[0], genericArguments[1], context, path);
		}
		else if (typeof(IEnumerable).IsAssignableFrom(value.Type))
		{
			TraverseList(value, visitor, context, path);
		}
		else
		{
			TraverseProperties(value, visitor, context, path);
		}
	}

	protected virtual void TraverseDictionary<TContext>(IObjectDescriptor dictionary, IObjectGraphVisitor<TContext> visitor, Type keyType, Type valueType, TContext context, Stack<ObjectPathSegment> path)
	{
		visitor.VisitMappingStart(dictionary, keyType, valueType, context);
		bool flag = dictionary.Type.FullName.Equals("System.Dynamic.ExpandoObject");
		foreach (DictionaryEntry? item in (IDictionary)dictionary.NonNullValue())
		{
			DictionaryEntry value = item.Value;
			object obj = (flag ? namingConvention.Apply(value.Key.ToString()) : value.Key);
			IObjectDescriptor objectDescriptor = GetObjectDescriptor(obj, keyType);
			IObjectDescriptor objectDescriptor2 = GetObjectDescriptor(value.Value, valueType);
			if (visitor.EnterMapping(objectDescriptor, objectDescriptor2, context))
			{
				Traverse(obj, objectDescriptor, visitor, context, path);
				Traverse(obj, objectDescriptor2, visitor, context, path);
			}
		}
		visitor.VisitMappingEnd(dictionary, context);
	}

	private void TraverseList<TContext>(IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path)
	{
		Type valueType = objectFactory.GetValueType(value.Type);
		visitor.VisitSequenceStart(value, valueType, context);
		int num = 0;
		foreach (object item in (IEnumerable)value.NonNullValue())
		{
			Traverse(num, GetObjectDescriptor(item, valueType), visitor, context, path);
			num++;
		}
		visitor.VisitSequenceEnd(value, context);
	}

	protected virtual void TraverseProperties<TContext>(IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path)
	{
		visitor.VisitMappingStart(value, typeof(string), typeof(object), context);
		object obj = value.NonNullValue();
		foreach (IPropertyDescriptor property in typeDescriptor.GetProperties(value.Type, obj))
		{
			IObjectDescriptor value2 = property.Read(obj);
			if (visitor.EnterMapping(property, value2, context))
			{
				Traverse(property.Name, new ObjectDescriptor(property.Name, typeof(string), typeof(string), ScalarStyle.Plain), visitor, context, path);
				Traverse(property.Name, value2, visitor, context, path);
			}
		}
		visitor.VisitMappingEnd(value, context);
	}

	private IObjectDescriptor GetObjectDescriptor(object? value, Type staticType)
	{
		return new ObjectDescriptor(value, typeResolver.Resolve(staticType, value), staticType);
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.ObjectGraphTraversalStrategies.RoundtripObjectGraphTraversalStrategy ----
namespace YamlDotNet.Serialization.ObjectGraphTraversalStrategies
{
internal class RoundtripObjectGraphTraversalStrategy : FullObjectGraphTraversalStrategy
{
	private readonly IEnumerable<IYamlTypeConverter> converters;

	private readonly Settings settings;

	public RoundtripObjectGraphTraversalStrategy(IEnumerable<IYamlTypeConverter> converters, ITypeInspector typeDescriptor, ITypeResolver typeResolver, int maxRecursion, INamingConvention namingConvention, Settings settings, IObjectFactory factory)
		: base(typeDescriptor, typeResolver, maxRecursion, namingConvention, factory)
	{
		this.converters = converters;
		this.settings = settings;
	}

	protected override void TraverseProperties<TContext>(IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path)
	{
		if (!value.Type.HasDefaultConstructor(settings.AllowPrivateConstructors) && !converters.Any((IYamlTypeConverter c) => c.Accepts(value.Type)))
		{
			throw new InvalidOperationException($"Type '{value.Type}' cannot be deserialized because it does not have a default constructor or a type converter.");
		}
		base.TraverseProperties(value, visitor, context, path);
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.ObjectFactories.DefaultObjectFactory ----
namespace YamlDotNet.Serialization.ObjectFactories
{
internal sealed class DefaultObjectFactory : ObjectFactoryBase
{
	private readonly Dictionary<Type, Type> DefaultGenericInterfaceImplementations = new Dictionary<Type, Type>
	{
		{
			typeof(IEnumerable<>),
			typeof(List<>)
		},
		{
			typeof(ICollection<>),
			typeof(List<>)
		},
		{
			typeof(IList<>),
			typeof(List<>)
		},
		{
			typeof(IDictionary<, >),
			typeof(Dictionary<, >)
		}
	};

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

	private readonly Settings settings;

	public DefaultObjectFactory()
		: this(new Dictionary<Type, Type>(), new Settings())
	{
	}

	public DefaultObjectFactory(IDictionary<Type, Type> mappings)
		: this(mappings, new Settings())
	{
	}

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

	public override object Create(Type type)
	{
		if (type.IsInterface())
		{
			Type value2;
			if (type.IsGenericType())
			{
				if (DefaultGenericInterfaceImplementations.TryGetValue(type.GetGenericTypeDefinition(), out Type value))
				{
					type = value.MakeGenericType(type.GetGenericArguments());
				}
			}
			else if (DefaultNonGenericInterfaceImplementations.TryGetValue(type, out value2))
			{
				type = value2;
			}
		}
		try
		{
			return Activator.CreateInstance(type, settings.AllowPrivateConstructors);
		}
		catch (Exception innerException)
		{
			throw new InvalidOperationException("Failed to create an instance of type '" + type.FullName + "'.", innerException);
		}
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.ObjectFactories.LambdaObjectFactory ----
namespace YamlDotNet.Serialization.ObjectFactories
{
internal sealed class LambdaObjectFactory : ObjectFactoryBase
{
	private readonly Func<Type, object> factory;

	public LambdaObjectFactory(Func<Type, object> factory)
	{
		this.factory = factory ?? throw new ArgumentNullException("factory");
	}

	public override object Create(Type type)
	{
		return factory(type);
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.ObjectFactories.ObjectFactoryBase ----
namespace YamlDotNet.Serialization.ObjectFactories
{
internal abstract class ObjectFactoryBase : IObjectFactory
{
	public abstract object Create(Type type);

	public virtual object? CreatePrimitive(Type type)
	{
		if (!type.IsValueType())
		{
			return null;
		}
		return Activator.CreateInstance(type);
	}

	public virtual bool GetDictionary(IObjectDescriptor descriptor, out IDictionary? dictionary, out Type[]? genericArguments)
	{
		Type implementedGenericInterface = ReflectionUtility.GetImplementedGenericInterface(descriptor.Type, typeof(IDictionary<, >));
		if (implementedGenericInterface != null)
		{
			genericArguments = implementedGenericInterface.GetGenericArguments();
			object obj = Activator.CreateInstance(typeof(GenericDictionaryToNonGenericAdapter<, >).MakeGenericType(genericArguments), descriptor.Value);
			dictionary = obj as IDictionary;
			return true;
		}
		genericArguments = null;
		dictionary = null;
		return false;
	}

	public virtual Type GetValueType(Type type)
	{
		Type implementedGenericInterface = ReflectionUtility.GetImplementedGenericInterface(type, typeof(IEnumerable<>));
		if (!(implementedGenericInterface != null))
		{
			return typeof(object);
		}
		return implementedGenericInterface.GetGenericArguments()[0];
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.ObjectFactories.StaticObjectFactory ----
namespace YamlDotNet.Serialization.ObjectFactories
{
internal abstract class StaticObjectFactory : IObjectFactory
{
	public abstract object Create(Type type);

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

	public abstract bool IsDictionary(Type type);

	public abstract bool IsArray(Type type);

	public abstract bool IsList(Type type);

	public abstract Type GetKeyType(Type type);

	public abstract Type GetValueType(Type type);

	public virtual object? CreatePrimitive(Type type)
	{
		return Type.GetTypeCode(type) switch
		{
			TypeCode.Boolean => false, 
			TypeCode.Byte => (byte)0, 
			TypeCode.Int16 => (short)0, 
			TypeCode.Int32 => 0, 
			TypeCode.Int64 => 0L, 
			TypeCode.SByte => (sbyte)0, 
			TypeCode.UInt16 => (ushort)0, 
			TypeCode.UInt32 => 0u, 
			TypeCode.UInt64 => 0uL, 
			TypeCode.Single => 0f, 
			TypeCode.Double => 0.0, 
			TypeCode.Decimal => 0m, 
			TypeCode.Char => '\0', 
			TypeCode.DateTime => default(DateTime), 
			_ => null, 
		};
	}

	public bool GetDictionary(IObjectDescriptor descriptor, out IDictionary? dictionary, out Type[]? genericArguments)
	{
		dictionary = null;
		genericArguments = null;
		return false;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.NodeTypeResolvers.DefaultContainersNodeTypeResolver ----
namespace YamlDotNet.Serialization.NodeTypeResolvers
{
internal sealed class DefaultContainersNodeTypeResolver : INodeTypeResolver
{
	bool INodeTypeResolver.Resolve(NodeEvent? nodeEvent, ref Type currentType)
	{
		if (currentType == typeof(object))
		{
			if (nodeEvent is SequenceStart)
			{
				currentType = typeof(List<object>);
				return true;
			}
			if (nodeEvent is MappingStart)
			{
				currentType = typeof(Dictionary<object, object>);
				return true;
			}
		}
		return false;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.NodeTypeResolvers.MappingNodeTypeResolver ----
namespace YamlDotNet.Serialization.NodeTypeResolvers
{
internal class MappingNodeTypeResolver : INodeTypeResolver
{
	private readonly IDictionary<Type, Type> _mappings;

	public MappingNodeTypeResolver(IDictionary<Type, Type> mappings)
	{
		if (mappings == null)
		{
			throw new ArgumentNullException("mappings");
		}
		foreach (KeyValuePair<Type, Type> mapping in mappings)
		{
			if (!mapping.Key.IsAssignableFrom(mapping.Value))
			{
				throw new InvalidOperationException($"Type '{mapping.Value}' does not implement type '{mapping.Key}'.");
			}
		}
		_mappings = mappings;
	}

	public bool Resolve(NodeEvent? nodeEvent, ref Type currentType)
	{
		if (_mappings.TryGetValue(currentType, out Type value))
		{
			currentType = value;
			return true;
		}
		return false;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.NodeTypeResolvers.PreventUnknownTagsNodeTypeResolver ----
namespace YamlDotNet.Serialization.NodeTypeResolvers
{
internal class PreventUnknownTagsNodeTypeResolver : INodeTypeResolver
{
	bool INodeTypeResolver.Resolve(NodeEvent? nodeEvent, ref Type currentType)
	{
		if (nodeEvent != null && !nodeEvent.Tag.IsEmpty)
		{
			throw new YamlException(nodeEvent.Start, nodeEvent.End, $"Encountered an unresolved tag '{nodeEvent.Tag}'");
		}
		return false;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.NodeTypeResolvers.TagNodeTypeResolver ----
namespace YamlDotNet.Serialization.NodeTypeResolvers
{
internal sealed class TagNodeTypeResolver : INodeTypeResolver
{
	private readonly IDictionary<TagName, Type> tagMappings;

	public TagNodeTypeResolver(IDictionary<TagName, Type> tagMappings)
	{
		this.tagMappings = tagMappings ?? throw new ArgumentNullException("tagMappings");
	}

	bool INodeTypeResolver.Resolve(NodeEvent? nodeEvent, ref Type currentType)
	{
		if (nodeEvent != null && !nodeEvent.Tag.IsEmpty && tagMappings.TryGetValue(nodeEvent.Tag, out Type value))
		{
			currentType = value;
			return true;
		}
		return false;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.NodeTypeResolvers.TypeNameInTagNodeTypeResolver ----
namespace YamlDotNet.Serialization.NodeTypeResolvers
{
[Obsolete("The mechanism that this class uses to specify type names is non-standard. Register the tags explicitly instead of using this convention.")]
internal sealed class TypeNameInTagNodeTypeResolver : INodeTypeResolver
{
	bool INodeTypeResolver.Resolve(NodeEvent? nodeEvent, ref Type currentType)
	{
		if (nodeEvent != null && !nodeEvent.Tag.IsEmpty)
		{
			Type type = Type.GetType(nodeEvent.Tag.Value.Substring(1), throwOnError: false);
			if (type != null)
			{
				currentType = type;
				return true;
			}
		}
		return false;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.NodeTypeResolvers.YamlConvertibleTypeResolver ----
namespace YamlDotNet.Serialization.NodeTypeResolvers
{
internal sealed class YamlConvertibleTypeResolver : INodeTypeResolver
{
	public bool Resolve(NodeEvent? nodeEvent, ref Type currentType)
	{
		return typeof(IYamlConvertible).IsAssignableFrom(currentType);
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.NodeTypeResolvers.YamlSerializableTypeResolver ----
namespace YamlDotNet.Serialization.NodeTypeResolvers
{
internal sealed class YamlSerializableTypeResolver : INodeTypeResolver
{
	public bool Resolve(NodeEvent? nodeEvent, ref Type currentType)
	{
		return typeof(IYamlSerializable).IsAssignableFrom(currentType);
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.NodeDeserializers.ArrayNodeDeserializer ----
namespace YamlDotNet.Serialization.NodeDeserializers
{
internal sealed class ArrayNodeDeserializer : INodeDeserializer
{
	private sealed class ArrayList : IList, ICollection, IEnumerable
	{
		private object?[] data;

		public bool IsFixedSize => false;

		public bool IsReadOnly => false;

		public object? this[int index]
		{
			get
			{
				return data[index];
			}
			set
			{
				data[index] = value;
			}
		}

		public int Count { get; private set; }

		public bool IsSynchronized => false;

		public object SyncRoot => data;

		public ArrayList()
		{
			Clear();
		}

		public int Add(object? value)
		{
			if (Count == data.Length)
			{
				Array.Resize(ref data, data.Length * 2);
			}
			data[Count] = value;
			return Count++;
		}

		public void Clear()
		{
			data = new object[10];
			Count = 0;
		}

		bool IList.Contains(object? value)
		{
			throw new NotSupportedException();
		}

		int IList.IndexOf(object? value)
		{
			throw new NotSupportedException();
		}

		void IList.Insert(int index, object? value)
		{
			throw new NotSupportedException();
		}

		void IList.Remove(object? value)
		{
			throw new NotSupportedException();
		}

		void IList.RemoveAt(int index)
		{
			throw new NotSupportedException();
		}

		public void CopyTo(Array array, int index)
		{
			Array.Copy(data, 0, array, index, Count);
		}

		public IEnumerator GetEnumerator()
		{
			int i = 0;
			while (i < Count)
			{
				yield return data[i];
				int num = i + 1;
				i = num;
			}
		}
	}

	public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value)
	{
		if (!expectedType.IsArray)
		{
			value = false;
			return false;
		}
		Type elementType = expectedType.GetElementType();
		ArrayList arrayList = new ArrayList();
		CollectionNodeDeserializer.DeserializeHelper(elementType, parser, nestedObjectDeserializer, arrayList, canUpdate: true);
		Array array = Array.CreateInstance(elementType, arrayList.Count);
		arrayList.CopyTo(array, 0);
		value = array;
		return true;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.NodeDeserializers.CollectionDeserializer ----
namespace YamlDotNet.Serialization.NodeDeserializers
{
internal abstract class CollectionDeserializer
{
	protected static void DeserializeHelper(Type tItem, IParser parser, Func<IParser, Type, object?> nestedObjectDeserializer, IList result, bool canUpdate, IObjectFactory objectFactory)
	{
		parser.Consume<SequenceStart>();
		SequenceEnd @event;
		while (!parser.TryConsume<SequenceEnd>(out @event))
		{
			ParsingEvent current = parser.Current;
			object obj = nestedObjectDeserializer(parser, tItem);
			if (obj is IValuePromise valuePromise)
			{
				if (!canUpdate)
				{
					throw new ForwardAnchorNotSupportedException(current?.Start ?? Mark.Empty, current?.End ?? Mark.Empty, "Forward alias references are not allowed because this type does not implement IList<>");
				}
				int index = result.Add(objectFactory.CreatePrimitive(tItem));
				valuePromise.ValueAvailable += delegate(object? v)
				{
					result[index] = v;
				};
			}
			else
			{
				result.Add(obj);
			}
		}
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.NodeDeserializers.CollectionNodeDeserializer ----
namespace YamlDotNet.Serialization.NodeDeserializers
{
internal sealed class CollectionNodeDeserializer : INodeDeserializer
{
	private readonly IObjectFactory objectFactory;

	public CollectionNodeDeserializer(IObjectFactory objectFactory)
	{
		this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
	}

	public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value)
	{
		bool canUpdate = true;
		Type implementedGenericInterface = ReflectionUtility.GetImplementedGenericInterface(expectedType, typeof(ICollection<>));
		Type type;
		IList list;
		if (implementedGenericInterface != null)
		{
			type = implementedGenericInterface.GetGenericArguments()[0];
			value = objectFactory.Create(expectedType);
			list = value as IList;
			if (list == null)
			{
				canUpdate = ReflectionUtility.GetImplementedGenericInterface(expectedType, typeof(IList<>)) != null;
				list = (IList)Activator.CreateInstance(typeof(GenericCollectionToNonGenericAdapter<>).MakeGenericType(type), value);
			}
		}
		else
		{
			if (!typeof(IList).IsAssignableFrom(expectedType))
			{
				value = null;
				return false;
			}
			type = typeof(object);
			value = objectFactory.Create(expectedType);
			list = (IList)value;
		}
		DeserializeHelper(type, parser, nestedObjectDeserializer, list, canUpdate);
		return true;
	}

	internal static void DeserializeHelper(Type tItem, IParser parser, Func<IParser, Type, object?> nestedObjectDeserializer, IList result, bool canUpdate)
	{
		parser.Consume<SequenceStart>();
		SequenceEnd @event;
		while (!parser.TryConsume<SequenceEnd>(out @event))
		{
			ParsingEvent current = parser.Current;
			object obj = nestedObjectDeserializer(parser, tItem);
			if (obj is IValuePromise valuePromise)
			{
				if (!canUpdate)
				{
					throw new ForwardAnchorNotSupportedException(current?.Start ?? Mark.Empty, current?.End ?? Mark.Empty, "Forward alias references are not allowed because this type does not implement IList<>");
				}
				int index = result.Add(tItem.IsValueType() ? Activator.CreateInstance(tItem) : null);
				valuePromise.ValueAvailable += delegate(object? v)
				{
					result[index] = TypeConverter.ChangeType(v, tItem);
				};
			}
			else
			{
				result.Add(TypeConverter.ChangeType(obj, tItem));
			}
		}
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.NodeDeserializers.DictionaryDeserializer ----
namespace YamlDotNet.Serialization.NodeDeserializers
{
internal abstract class DictionaryDeserializer
{
	private readonly bool duplicateKeyChecking;

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

	private void TryAssign(IDictionary result, object key, object value, MappingStart propertyName)
	{
		if (duplicateKeyChecking && result.Contains(key))
		{
			throw new YamlException(propertyName.Start, propertyName.End, $"Encountered duplicate key {key}");
		}
		result[key] = value;
	}

	protected virtual void Deserialize(Type tKey, Type tValue, IParser parser, Func<IParser, Type, object?> nestedObjectDeserializer, IDictionary result)
	{
		MappingStart property = parser.Consume<MappingStart>();
		MappingEnd @event;
		while (!parser.TryConsume<MappingEnd>(out @event))
		{
			object key = nestedObjectDeserializer(parser, tKey);
			object value = nestedObjectDeserializer(parser, tValue);
			IValuePromise valuePromise = value as IValuePromise;
			if (key is IValuePromise valuePromise2)
			{
				if (valuePromise == null)
				{
					valuePromise2.ValueAvailable += delegate(object? v)
					{
						result[v] = value;
					};
					continue;
				}
				bool hasFirstPart = false;
				valuePromise2.ValueAvailable += delegate(object? v)
				{
					if (hasFirstPart)
					{
						TryAssign(result, v, value, property);
					}
					else
					{
						key = v;
						hasFirstPart = true;
					}
				};
				valuePromise.ValueAvailable += delegate(object? v)
				{
					if (hasFirstPart)
					{
						TryAssign(result, key, v, property);
					}
					else
					{
						value = v;
						hasFirstPart = true;
					}
				};
				continue;
			}
			if (key == null)
			{
				throw new ArgumentException("Empty key names are not supported yet.", "key");
			}
			if (valuePromise == null)
			{
				TryAssign(result, key, value, property);
				continue;
			}
			valuePromise.ValueAvailable += delegate(object? v)
			{
				result[key] = v;
			};
		}
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.NodeDeserializers.DictionaryNodeDeserializer ----
namespace YamlDotNet.Serialization.NodeDeserializers
{
internal class DictionaryNodeDeserializer : DictionaryDeserializer, INodeDeserializer
{
	private readonly IObjectFactory objectFactory;

	public DictionaryNodeDeserializer(IObjectFactory objectFactory, bool duplicateKeyChecking)
		: base(duplicateKeyChecking)
	{
		this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
	}

	public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value)
	{
		Type implementedGenericInterface = ReflectionUtility.GetImplementedGenericInterface(expectedType, typeof(IDictionary<, >));
		Type type;
		Type type2;
		IDictionary dictionary;
		if (implementedGenericInterface != null)
		{
			Type[] genericArguments = implementedGenericInterface.GetGenericArguments();
			type = genericArguments[0];
			type2 = genericArguments[1];
			value = objectFactory.Create(expectedType);
			dictionary = value as IDictionary;
			if (dictionary == null)
			{
				dictionary = (IDictionary)Activator.CreateInstance(typeof(GenericDictionaryToNonGenericAdapter<, >).MakeGenericType(type, type2), value);
			}
		}
		else
		{
			if (!typeof(IDictionary).IsAssignableFrom(expectedType))
			{
				value = null;
				return false;
			}
			type = typeof(object);
			type2 = typeof(object);
			value = objectFactory.Create(expectedType);
			dictionary = (IDictionary)value;
		}
		Deserialize(type, type2, parser, nestedObjectDeserializer, dictionary);
		return true;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.NodeDeserializers.EnumerableNodeDeserializer ----
namespace YamlDotNet.Serialization.NodeDeserializers
{
internal sealed class EnumerableNodeDeserializer : INodeDeserializer
{
	public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value)
	{
		Type type;
		if (expectedType == typeof(IEnumerable))
		{
			type = typeof(object);
		}
		else
		{
			Type implementedGenericInterface = ReflectionUtility.GetImplementedGenericInterface(expectedType, typeof(IEnumerable<>));
			if (implementedGenericInterface != expectedType)
			{
				value = null;
				return false;
			}
			type = implementedGenericInterface.GetGenericArguments()[0];
		}
		Type arg = typeof(List<>).MakeGenericType(type);
		value = nestedObjectDeserializer(parser, arg);
		return true;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.NodeDeserializers.NullNodeDeserializer ----
namespace YamlDotNet.Serialization.NodeDeserializers
{
internal sealed class NullNodeDeserializer : INodeDeserializer
{
	public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value)
	{
		value = null;
		if (parser.Accept<NodeEvent>(out var @event) && NodeIsNull(@event))
		{
			parser.SkipThisAndNestedEvents();
			return true;
		}
		return false;
	}

	private bool NodeIsNull(NodeEvent nodeEvent)
	{
		if (nodeEvent.Tag == "tag:yaml.org,2002:null")
		{
			return true;
		}
		if (nodeEvent is Scalar { Style: ScalarStyle.Plain, IsKey: false } scalar)
		{
			string value = scalar.Value;
			switch (value)
			{
			default:
				return value == "NULL";
			case "":
			case "~":
			case "null":
			case "Null":
				return true;
			}
		}
		return false;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.NodeDeserializers.ObjectNodeDeserializer ----
namespace YamlDotNet.Serialization.NodeDeserializers
{
internal sealed class ObjectNodeDeserializer : INodeDeserializer
{
	private readonly IObjectFactory objectFactory;

	private readonly ITypeInspector typeDescriptor;

	private readonly bool ignoreUnmatched;

	private readonly bool duplicateKeyChecking;

	private readonly ITypeConverter typeConverter;

	public ObjectNodeDeserializer(IObjectFactory objectFactory, ITypeInspector typeDescriptor, bool ignoreUnmatched, bool duplicateKeyChecking, ITypeConverter typeConverter)
	{
		this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
		this.typeDescriptor = typeDescriptor ?? throw new ArgumentNullException("typeDescriptor");
		this.ignoreUnmatched = ignoreUnmatched;
		this.duplicateKeyChecking = duplicateKeyChecking;
		this.typeConverter = typeConverter ?? throw new ArgumentNullException("typeConverter");
	}

	public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value)
	{
		if (!parser.TryConsume<MappingStart>(out var _))
		{
			value = null;
			return false;
		}
		Type type = Nullable.GetUnderlyingType(expectedType) ?? expectedType;
		value = objectFactory.Create(type);
		HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
		MappingEnd event2;
		while (!parser.TryConsume<MappingEnd>(out event2))
		{
			Scalar scalar = parser.Consume<Scalar>();
			if (duplicateKeyChecking && !hashSet.Add(scalar.Value))
			{
				throw new YamlException(scalar.Start, scalar.End, "Encountered duplicate key " + scalar.Value);
			}
			try
			{
				IPropertyDescriptor property = typeDescriptor.GetProperty(type, null, scalar.Value, ignoreUnmatched);
				if (property == null)
				{
					parser.SkipThisAndNestedEvents();
					continue;
				}
				object obj = nestedObjectDeserializer(parser, property.Type);
				if (obj is IValuePromise valuePromise)
				{
					object valueRef = value;
					valuePromise.ValueAvailable += delegate(object? v)
					{
						object value3 = typeConverter.ChangeType(v, property.Type);
						property.Write(valueRef, value3);
					};
				}
				else
				{
					object value2 = typeConverter.ChangeType(obj, property.Type);
					property.Write(value, value2);
				}
			}
			catch (SerializationException ex)
			{
				throw new YamlException(scalar.Start, scalar.End, ex.Message);
			}
			catch (YamlException)
			{
				throw;
			}
			catch (Exception innerException)
			{
				throw new YamlException(scalar.Start, scalar.End, "Exception during deserialization", innerException);
			}
		}
		return true;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.NodeDeserializers.ScalarNodeDeserializer ----
namespace YamlDotNet.Serialization.NodeDeserializers
{
internal sealed class ScalarNodeDeserializer : INodeDeserializer
{
	private const string BooleanTruePattern = "^(true|y|yes|on)$";

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

	private readonly bool attemptUnknownTypeDeserialization;

	private readonly ITypeConverter typeConverter;

	public ScalarNodeDeserializer(bool attemptUnknownTypeDeserialization, ITypeConverter typeConverter)
	{
		this.attemptUnknownTypeDeserialization = attemptUnknownTypeDeserialization;
		this.typeConverter = typeConverter ?? throw new ArgumentNullException("typeConverter");
	}

	public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value)
	{
		if (!parser.TryConsume<Scalar>(out var @event))
		{
			value = null;
			return false;
		}
		Type type = Nullable.GetUnderlyingType(expectedType) ?? expectedType;
		if (type.IsEnum())
		{
			value = Enum.Parse(type, @event.Value, ignoreCase: true);
			return true;
		}
		TypeCode typeCode = type.GetTypeCode();
		switch (typeCode)
		{
		case TypeCode.Boolean:
			value = DeserializeBooleanHelper(@event.Value);
			break;
		case TypeCode.SByte:
		case TypeCode.Byte:
		case TypeCode.Int16:
		case TypeCode.UInt16:
		case TypeCode.Int32:
		case TypeCode.UInt32:
		case TypeCode.Int64:
		case TypeCode.UInt64:
			value = DeserializeIntegerHelper(typeCode, @event.Value);
			break;
		case TypeCode.Single:
			value = float.Parse(@event.Value, YamlFormatter.NumberFormat);
			break;
		case TypeCode.Double:
			value = double.Parse(@event.Value, YamlFormatter.NumberFormat);
			break;
		case TypeCode.Decimal:
			value = decimal.Parse(@event.Value, YamlFormatter.NumberFormat);
			break;
		case TypeCode.String:
			value = @event.Value;
			break;
		case TypeCode.Char:
			value = @event.Value[0];
			break;
		case TypeCode.DateTime:
			value = DateTime.Parse(@event.Value, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind);
			break;
		default:
			if (expectedType == typeof(object))
			{
				if (!@event.IsKey && attemptUnknownTypeDeserialization)
				{
					value = AttemptUnknownTypeDeserialization(@event);
				}
				else
				{
					value = @event.Value;
				}
			}
			else
			{
				value = typeConverter.ChangeType(@event.Value, expectedType);
			}
			break;
		}
		return true;
	}

	private object DeserializeBooleanHelper(string value)
	{
		bool flag;
		if (Regex.IsMatch(value, "^(true|y|yes|on)$", RegexOptions.IgnoreCase))
		{
			flag = true;
		}
		else
		{
			if (!Regex.IsMatch(value, "^(false|n|no|off)$", RegexOptions.IgnoreCase))
			{
				throw new FormatException("The value \"" + value + "\" is not a valid YAML Boolean");
			}
			flag = false;
		}
		return flag;
	}

	private static object DeserializeIntegerHelper(TypeCode typeCode, string value)
	{
		StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
		try
		{
			StringBuilder builder = builderWrapper.Builder;
			int i = 0;
			bool flag = false;
			ulong num = 0uL;
			if (value[0] == '-')
			{
				i++;
				flag = true;
			}
			else if (value[0] == '+')
			{
				i++;
			}
			if (value[i] == '0')
			{
				int num2;
				if (i == value.Length - 1)
				{
					num2 = 10;
					num = 0uL;
				}
				else
				{
					i++;
					if (value[i] == 'b')
					{
						num2 = 2;
						i++;
					}
					else if (value[i] == 'x')
					{
						num2 = 16;
						i++;
					}
					else
					{
						num2 = 8;
					}
				}
				for (; i < value.Length; i++)
				{
					if (value[i] != '_')
					{
						builder.Append(value[i]);
					}
				}
				switch (num2)
				{
				case 2:
				case 8:
					num = Convert.ToUInt64(builder.ToString(), num2);
					break;
				case 16:
					num = ulong.Parse(builder.ToString(), NumberStyles.HexNumber, YamlFormatter.NumberFormat);
					break;
				}
			}
			else
			{
				string[] array = value.Substring(i).Split(new char[1] { ':' });
				num = 0uL;
				for (int j = 0; j < array.Length; j++)
				{
					num *= 60;
					num += ulong.Parse(array[j].Replace("_", ""));
				}
			}
			if (!flag)
			{
				return CastInteger(num, typeCode);
			}
			long number = ((num != 9223372036854775808uL) ? checked(-(long)num) : long.MinValue);
			return CastInteger(number, typeCode);
		}
		finally
		{
			((IDisposable)builderWrapper/*cast due to constrained. prefix*//*cast due to constrained. prefix*/).Dispose();
		}
	}

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

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

	private static object? AttemptUnknownTypeDeserialization(Scalar value)
	{
		if (value.Style == ScalarStyle.SingleQuoted || value.Style == ScalarStyle.DoubleQuoted || value.Style == ScalarStyle.Folded)
		{
			return value.Value;
		}
		string v = value.Value;
		switch (v)
		{
		case "null":
		case "Null":
		case "NULL":
		case "~":
		case "":
			return null;
		case "true":
		case "True":
		case "TRUE":
			return true;
		case "False":
		case "FALSE":
		case "false":
			return false;
		default:
		{
			object value2;
			if (Regex.IsMatch(v, "0x[0-9a-fA-F]+"))
			{
				if (!TryAndSwallow(() => Convert.ToByte(v, 16), out value2) && !TryAndSwallow(() => Convert.ToInt16(v, 16), out value2) && !TryAndSwallow(() => Convert.ToInt32(v, 16), out value2) && !TryAndSwallow(() => Convert.ToInt64(v, 16), out value2) && !TryAndSwallow(() => Convert.ToUInt64(v, 16), out value2))
				{
					return v;
				}
			}
			else if (Regex.IsMatch(v, "0o[0-9a-fA-F]+"))
			{
				if (!TryAndSwallow(() => Convert.ToByte(v, 8), out value2) && !TryAndSwallow(() => Convert.ToInt16(v, 8), out value2) && !TryAndSwallow(() => Convert.ToInt32(v, 8), out value2) && !TryAndSwallow(() => Convert.ToInt64(v, 8), out value2) && !TryAndSwallow(() => Convert.ToUInt64(v, 8), out value2))
				{
					return v;
				}
			}
			else
			{
				if (!Regex.IsMatch(v, "[-+]?(\\.[0-9]+|[0-9]+(\\.[0-9]*)?)([eE][-+]?[0-9]+)?"))
				{
					if (Regex.IsMatch(v, "^[-+]?(\\.inf|\\.Inf|\\.INF)$"))
					{
						if (v.StartsWith("-"))
						{
							return float.NegativeInfinity;
						}
						return float.PositiveInfinity;
					}
					if (Regex.IsMatch(v, "^(\\.nan|\\.NaN|\\.NAN)$"))
					{
						return float.NaN;
					}
					return v;
				}
				if (!TryAndSwallow(() => byte.Parse(v), out value2) && !TryAndSwallow(() => short.Parse(v), out value2) && !TryAndSwallow(() => int.Parse(v), out value2) && !TryAndSwallow(() => long.Parse(v), out value2) && !TryAndSwallow(() => ulong.Parse(v), out value2) && !TryAndSwallow(() => float.Parse(v), out value2) && !TryAndSwallow(() => double.Parse(v), out value2))
				{
					return v;
				}
			}
			return value2;
		}
		}
	}

	private static bool TryAndSwallow(Func<object> attempt, out object? value)
	{
		try
		{
			value = attempt();
			return true;
		}
		catch
		{
			value = null;
			return false;
		}
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.NodeDeserializers.StaticArrayNodeDeserializer ----
namespace YamlDotNet.Serialization.NodeDeserializers
{
internal sealed class StaticArrayNodeDeserializer : INodeDeserializer
{
	private sealed class ArrayList : IList, ICollection, IEnumerable
	{
		private object?[] data;

		public bool IsFixedSize => false;

		public bool IsReadOnly => false;

		public object? this[int index]
		{
			get
			{
				return data[index];
			}
			set
			{
				data[index] = value;
			}
		}

		public int Count { get; private set; }

		public bool IsSynchronized => false;

		public object SyncRoot => data;

		public ArrayList()
		{
			Clear();
		}

		public int Add(object? value)
		{
			if (Count == data.Length)
			{
				Array.Resize(ref data, data.Length * 2);
			}
			data[Count] = value;
			return Count++;
		}

		public void Clear()
		{
			data = new object[10];
			Count = 0;
		}

		bool IList.Contains(object? value)
		{
			throw new NotSupportedException();
		}

		int IList.IndexOf(object? value)
		{
			throw new NotSupportedException();
		}

		void IList.Insert(int index, object? value)
		{
			throw new NotSupportedException();
		}

		void IList.Remove(object? value)
		{
			throw new NotSupportedException();
		}

		void IList.RemoveAt(int index)
		{
			throw new NotSupportedException();
		}

		public void CopyTo(Array array, int index)
		{
			Array.Copy(data, 0, array, index, Count);
		}

		public IEnumerator GetEnumerator()
		{
			int i = 0;
			while (i < Count)
			{
				yield return data[i];
				int num = i + 1;
				i = num;
			}
		}
	}

	private readonly StaticObjectFactory factory;

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

	public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value)
	{
		if (!factory.IsArray(expectedType))
		{
			value = false;
			return false;
		}
		Type valueType = factory.GetValueType(expectedType);
		ArrayList arrayList = new ArrayList();
		StaticCollectionNodeDeserializer.DeserializeHelper(valueType, parser, nestedObjectDeserializer, arrayList, factory);
		Array array = factory.CreateArray(expectedType, arrayList.Count);
		arrayList.CopyTo(array, 0);
		value = array;
		return true;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.NodeDeserializers.StaticCollectionNodeDeserializer ----
namespace YamlDotNet.Serialization.NodeDeserializers
{
internal sealed class StaticCollectionNodeDeserializer : INodeDeserializer
{
	private readonly StaticObjectFactory factory;

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

	public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value)
	{
		if (!factory.IsList(expectedType))
		{
			value = null;
			return false;
		}
		DeserializeHelper(result: (IList)(value = factory.Create(expectedType) as IList), tItem: factory.GetValueType(expectedType), parser: parser, nestedObjectDeserializer: nestedObjectDeserializer, factory: factory);
		return true;
	}

	internal static void DeserializeHelper(Type tItem, IParser parser, Func<IParser, Type, object?> nestedObjectDeserializer, IList result, IObjectFactory factory)
	{
		parser.Consume<SequenceStart>();
		SequenceEnd @event;
		while (!parser.TryConsume<SequenceEnd>(out @event))
		{
			_ = parser.Current;
			object obj = nestedObjectDeserializer(parser, tItem);
			if (obj is IValuePromise valuePromise)
			{
				int index = result.Add(factory.CreatePrimitive(tItem));
				valuePromise.ValueAvailable += delegate(object? v)
				{
					result[index] = v;
				};
			}
			else
			{
				result.Add(obj);
			}
		}
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.NodeDeserializers.StaticDictionaryNodeDeserializer ----
namespace YamlDotNet.Serialization.NodeDeserializers
{
internal class StaticDictionaryNodeDeserializer : DictionaryDeserializer, INodeDeserializer
{
	private readonly StaticObjectFactory _objectFactory;

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

	public bool Deserialize(IParser reader, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value)
	{
		if (_objectFactory.IsDictionary(expectedType))
		{
			if (!(_objectFactory.Create(expectedType) is IDictionary dictionary))
			{
				value = null;
				return false;
			}
			Type keyType = _objectFactory.GetKeyType(expectedType);
			Type valueType = _objectFactory.GetValueType(expectedType);
			value = dictionary;
			base.Deserialize(keyType, valueType, reader, nestedObjectDeserializer, dictionary);
			return true;
		}
		value = null;
		return false;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.NodeDeserializers.TypeConverterNodeDeserializer ----
namespace YamlDotNet.Serialization.NodeDeserializers
{
internal sealed class TypeConverterNodeDeserializer : INodeDeserializer
{
	private readonly IEnumerable<IYamlTypeConverter> converters;

	public TypeConverterNodeDeserializer(IEnumerable<IYamlTypeConverter> converters)
	{
		this.converters = converters ?? throw new ArgumentNullException("converters");
	}

	public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value)
	{
		IYamlTypeConverter yamlTypeConverter = converters.FirstOrDefault((IYamlTypeConverter c) => c.Accepts(expectedType));
		if (yamlTypeConverter == null)
		{
			value = null;
			return false;
		}
		value = yamlTypeConverter.ReadYaml(parser, expectedType);
		return true;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.NodeDeserializers.YamlConvertibleNodeDeserializer ----
namespace YamlDotNet.Serialization.NodeDeserializers
{
internal sealed class YamlConvertibleNodeDeserializer : INodeDeserializer
{
	private readonly IObjectFactory objectFactory;

	public YamlConvertibleNodeDeserializer(IObjectFactory objectFactory)
	{
		this.objectFactory = objectFactory;
	}

	public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value)
	{
		if (typeof(IYamlConvertible).IsAssignableFrom(expectedType))
		{
			IYamlConvertible yamlConvertible = (IYamlConvertible)objectFactory.Create(expectedType);
			yamlConvertible.Read(parser, expectedType, (Type type) => nestedObjectDeserializer(parser, type));
			value = yamlConvertible;
			return true;
		}
		value = null;
		return false;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.NodeDeserializers.YamlSerializableNodeDeserializer ----
namespace YamlDotNet.Serialization.NodeDeserializers
{
internal sealed class YamlSerializableNodeDeserializer : INodeDeserializer
{
	private readonly IObjectFactory objectFactory;

	public YamlSerializableNodeDeserializer(IObjectFactory objectFactory)
	{
		this.objectFactory = objectFactory;
	}

	public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value)
	{
		if (typeof(IYamlSerializable).IsAssignableFrom(expectedType))
		{
			IYamlSerializable yamlSerializable = (IYamlSerializable)objectFactory.Create(expectedType);
			yamlSerializable.ReadYaml(parser);
			value = yamlSerializable;
			return true;
		}
		value = null;
		return false;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.NamingConventions.CamelCaseNamingConvention ----
namespace YamlDotNet.Serialization.NamingConventions
{
internal sealed class CamelCaseNamingConvention : INamingConvention
{
	public static readonly INamingConvention Instance = new CamelCaseNamingConvention();

	[Obsolete("Use the Instance static field instead of creating new instances")]
	public CamelCaseNamingConvention()
	{
	}

	public string Apply(string value)
	{
		return value.ToCamelCase();
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.NamingConventions.HyphenatedNamingConvention ----
namespace YamlDotNet.Serialization.NamingConventions
{
internal sealed class HyphenatedNamingConvention : INamingConvention
{
	public static readonly INamingConvention Instance = new HyphenatedNamingConvention();

	[Obsolete("Use the Instance static field instead of creating new instances")]
	public HyphenatedNamingConvention()
	{
	}

	public string Apply(string value)
	{
		return value.FromCamelCase("-");
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.NamingConventions.LowerCaseNamingConvention ----
namespace YamlDotNet.Serialization.NamingConventions
{
internal sealed class LowerCaseNamingConvention : INamingConvention
{
	public static readonly INamingConvention Instance = new LowerCaseNamingConvention();

	private LowerCaseNamingConvention()
	{
	}

	public string Apply(string value)
	{
		return value.ToCamelCase().ToLower();
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.NamingConventions.NullNamingConvention ----
namespace YamlDotNet.Serialization.NamingConventions
{
internal sealed class NullNamingConvention : INamingConvention
{
	public static readonly INamingConvention Instance = new NullNamingConvention();

	[Obsolete("Use the Instance static field instead of creating new instances")]
	public NullNamingConvention()
	{
	}

	public string Apply(string value)
	{
		return value;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.NamingConventions.PascalCaseNamingConvention ----
namespace YamlDotNet.Serialization.NamingConventions
{
internal sealed class PascalCaseNamingConvention : INamingConvention
{
	public static readonly INamingConvention Instance = new PascalCaseNamingConvention();

	[Obsolete("Use the Instance static field instead of creating new instances")]
	public PascalCaseNamingConvention()
	{
	}

	public string Apply(string value)
	{
		return value.ToPascalCase();
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.NamingConventions.UnderscoredNamingConvention ----
namespace YamlDotNet.Serialization.NamingConventions
{
internal sealed class UnderscoredNamingConvention : INamingConvention
{
	public static readonly INamingConvention Instance = new UnderscoredNamingConvention();

	[Obsolete("Use the Instance static field instead of creating new instances")]
	public UnderscoredNamingConvention()
	{
	}

	public string Apply(string value)
	{
		return value.FromCamelCase("_");
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.EventEmitters.ChainedEventEmitter ----
namespace YamlDotNet.Serialization.EventEmitters
{
internal abstract class ChainedEventEmitter : IEventEmitter
{
	protected readonly IEventEmitter nextEmitter;

	protected ChainedEventEmitter(IEventEmitter nextEmitter)
	{
		this.nextEmitter = nextEmitter ?? throw new ArgumentNullException("nextEmitter");
	}

	public virtual void Emit(AliasEventInfo eventInfo, IEmitter emitter)
	{
		nextEmitter.Emit(eventInfo, emitter);
	}

	public virtual void Emit(ScalarEventInfo eventInfo, IEmitter emitter)
	{
		nextEmitter.Emit(eventInfo, emitter);
	}

	public virtual void Emit(MappingStartEventInfo eventInfo, IEmitter emitter)
	{
		nextEmitter.Emit(eventInfo, emitter);
	}

	public virtual void Emit(MappingEndEventInfo eventInfo, IEmitter emitter)
	{
		nextEmitter.Emit(eventInfo, emitter);
	}

	public virtual void Emit(SequenceStartEventInfo eventInfo, IEmitter emitter)
	{
		nextEmitter.Emit(eventInfo, emitter);
	}

	public virtual void Emit(SequenceEndEventInfo eventInfo, IEmitter emitter)
	{
		nextEmitter.Emit(eventInfo, emitter);
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.EventEmitters.JsonEventEmitter ----
namespace YamlDotNet.Serialization.EventEmitters
{
internal sealed class JsonEventEmitter : ChainedEventEmitter
{
	public JsonEventEmitter(IEventEmitter nextEmitter)
		: base(nextEmitter)
	{
	}

	public override void Emit(AliasEventInfo eventInfo, IEmitter emitter)
	{
		eventInfo.NeedsExpansion = true;
	}

	public override void Emit(ScalarEventInfo eventInfo, IEmitter emitter)
	{
		eventInfo.IsPlainImplicit = true;
		eventInfo.Style = ScalarStyle.Plain;
		object value = eventInfo.Source.Value;
		if (value == null)
		{
			eventInfo.RenderedValue = "null";
		}
		else
		{
			TypeCode typeCode = eventInfo.Source.Type.GetTypeCode();
			switch (typeCode)
			{
			case TypeCode.Boolean:
				eventInfo.RenderedValue = YamlFormatter.FormatBoolean(value);
				break;
			case TypeCode.SByte:
			case TypeCode.Byte:
			case TypeCode.Int16:
			case TypeCode.UInt16:
			case TypeCode.Int32:
			case TypeCode.UInt32:
			case TypeCode.Int64:
			case TypeCode.UInt64:
				if (eventInfo.Source.Type.IsEnum())
				{
					eventInfo.RenderedValue = value.ToString();
					eventInfo.Style = ScalarStyle.DoubleQuoted;
				}
				else
				{
					eventInfo.RenderedValue = YamlFormatter.FormatNumber(value);
				}
				break;
			case TypeCode.Single:
			case TypeCode.Double:
			case TypeCode.Decimal:
				eventInfo.RenderedValue = YamlFormatter.FormatNumber(value);
				break;
			case TypeCode.Char:
			case TypeCode.String:
				eventInfo.RenderedValue = value.ToString();
				eventInfo.Style = ScalarStyle.DoubleQuoted;
				break;
			case TypeCode.DateTime:
				eventInfo.RenderedValue = YamlFormatter.FormatDateTime(value);
				break;
			case TypeCode.Empty:
				eventInfo.RenderedValue = "null";
				break;
			default:
				if (eventInfo.Source.Type == typeof(TimeSpan))
				{
					eventInfo.RenderedValue = YamlFormatter.FormatTimeSpan(value);
					break;
				}
				throw new NotSupportedException($"TypeCode.{typeCode} is not supported.");
			}
		}
		base.Emit(eventInfo, emitter);
	}

	public override void Emit(MappingStartEventInfo eventInfo, IEmitter emitter)
	{
		eventInfo.Style = MappingStyle.Flow;
		base.Emit(eventInfo, emitter);
	}

	public override void Emit(SequenceStartEventInfo eventInfo, IEmitter emitter)
	{
		eventInfo.Style = SequenceStyle.Flow;
		base.Emit(eventInfo, emitter);
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.EventEmitters.TypeAssigningEventEmitter ----
namespace YamlDotNet.Serialization.EventEmitters
{
internal sealed class TypeAssigningEventEmitter : ChainedEventEmitter
{
	private readonly bool requireTagWhenStaticAndActualTypesAreDifferent;

	private readonly IDictionary<Type, TagName> tagMappings;

	private readonly bool quoteNecessaryStrings;

	private readonly Regex? isSpecialStringValue_Regex;

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

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

	private readonly ScalarStyle defaultScalarStyle;

	public TypeAssigningEventEmitter(IEventEmitter nextEmitter, bool requireTagWhenStaticAndActualTypesAreDifferent, IDictionary<Type, TagName> tagMappings, bool quoteNecessaryStrings, bool quoteYaml1_1Strings, ScalarStyle defaultScalarStyle)
		: this(nextEmitter, requireTagWhenStaticAndActualTypesAreDifferent, tagMappings, quoteNecessaryStrings, quoteYaml1_1Strings)
	{
		this.defaultScalarStyle = defaultScalarStyle;
	}

	public TypeAssigningEventEmitter(IEventEmitter nextEmitter, bool requireTagWhenStaticAndActualTypesAreDifferent, IDictionary<Type, TagName> tagMappings, bool quoteNecessaryStrings, ScalarStyle defaultScalarStyle)
		: this(nextEmitter, requireTagWhenStaticAndActualTypesAreDifferent, tagMappings, quoteNecessaryStrings)
	{
		this.defaultScalarStyle = defaultScalarStyle;
	}

	public TypeAssigningEventEmitter(IEventEmitter nextEmitter, bool requireTagWhenStaticAndActualTypesAreDifferent, IDictionary<Type, TagName> tagMappings, bool quoteNecessaryStrings, bool quoteYaml1_1Strings)
		: this(nextEmitter, requireTagWhenStaticAndActualTypesAreDifferent, tagMappings)
	{
		this.quoteNecessaryStrings = quoteNecessaryStrings;
		isSpecialStringValue_Regex = new Regex(quoteYaml1_1Strings ? CombinedYaml1_1SpecialStrings_Pattern : SpecialStrings_Pattern, RegexOptions.Compiled);
	}

	public TypeAssigningEventEmitter(IEventEmitter nextEmitter, bool requireTagWhenStaticAndActualTypesAreDifferent, IDictionary<Type, TagName> tagMappings, bool quoteNecessaryStrings)
		: this(nextEmitter, requireTagWhenStaticAndActualTypesAreDifferent, tagMappings)
	{
		this.quoteNecessaryStrings = quoteNecessaryStrings;
		isSpecialStringValue_Regex = new Regex(SpecialStrings_Pattern, RegexOptions.Compiled);
	}

	public TypeAssigningEventEmitter(IEventEmitter nextEmitter, bool requireTagWhenStaticAndActualTypesAreDifferent, IDictionary<Type, TagName> tagMappings)
		: base(nextEmitter)
	{
		this.requireTagWhenStaticAndActualTypesAreDifferent = requireTagWhenStaticAndActualTypesAreDifferent;
		this.tagMappings = tagMappings ?? throw new ArgumentNullException("tagMappings");
	}

	public override void Emit(ScalarEventInfo eventInfo, IEmitter emitter)
	{
		ScalarStyle style = ScalarStyle.Plain;
		object value = eventInfo.Source.Value;
		if (value == null)
		{
			eventInfo.Tag = JsonSchema.Tags.Null;
			eventInfo.RenderedValue = "";
		}
		else
		{
			TypeCode typeCode = eventInfo.Source.Type.GetTypeCode();
			switch (typeCode)
			{
			case TypeCode.Boolean:
				eventInfo.Tag = JsonSchema.Tags.Bool;
				eventInfo.RenderedValue = YamlFormatter.FormatBoolean(value);
				break;
			case TypeCode.SByte:
			case TypeCode.Byte:
			case TypeCode.Int16:
			case TypeCode.UInt16:
			case TypeCode.Int32:
			case TypeCode.UInt32:
			case TypeCode.Int64:
			case TypeCode.UInt64:
				if (eventInfo.Source.Type.IsEnum)
				{
					eventInfo.Tag = FailsafeSchema.Tags.Str;
					eventInfo.RenderedValue = value.ToString();
					style = ((!quoteNecessaryStrings || !IsSpecialStringValue(eventInfo.RenderedValue)) ? defaultScalarStyle : ScalarStyle.DoubleQuoted);
				}
				else
				{
					eventInfo.Tag = JsonSchema.Tags.Int;
					eventInfo.RenderedValue = YamlFormatter.FormatNumber(value);
				}
				break;
			case TypeCode.Single:
				eventInfo.Tag = JsonSchema.Tags.Float;
				eventInfo.RenderedValue = YamlFormatter.FormatNumber((float)value);
				break;
			case TypeCode.Double:
				eventInfo.Tag = JsonSchema.Tags.Float;
				eventInfo.RenderedValue = YamlFormatter.FormatNumber((double)value);
				break;
			case TypeCode.Decimal:
				eventInfo.Tag = JsonSchema.Tags.Float;
				eventInfo.RenderedValue = YamlFormatter.FormatNumber(value);
				break;
			case TypeCode.Char:
			case TypeCode.String:
				eventInfo.Tag = FailsafeSchema.Tags.Str;
				eventInfo.RenderedValue = value.ToString();
				style = ((!quoteNecessaryStrings || !IsSpecialStringValue(eventInfo.RenderedValue)) ? defaultScalarStyle : ScalarStyle.DoubleQuoted);
				break;
			case TypeCode.DateTime:
				eventInfo.Tag = DefaultSchema.Tags.Timestamp;
				eventInfo.RenderedValue = YamlFormatter.FormatDateTime(value);
				break;
			case TypeCode.Empty:
				eventInfo.Tag = JsonSchema.Tags.Null;
				eventInfo.RenderedValue = "";
				break;
			default:
				if (eventInfo.Source.Type == typeof(TimeSpan))
				{
					eventInfo.RenderedValue = YamlFormatter.FormatTimeSpan(value);
					break;
				}
				throw new NotSupportedException($"TypeCode.{typeCode} is not supported.");
			}
		}
		eventInfo.IsPlainImplicit = true;
		if (eventInfo.Style == ScalarStyle.Any)
		{
			eventInfo.Style = style;
		}
		base.Emit(eventInfo, emitter);
	}

	public override void Emit(MappingStartEventInfo eventInfo, IEmitter emitter)
	{
		AssignTypeIfNeeded(eventInfo);
		base.Emit(eventInfo, emitter);
	}

	public override void Emit(SequenceStartEventInfo eventInfo, IEmitter emitter)
	{
		AssignTypeIfNeeded(eventInfo);
		base.Emit(eventInfo, emitter);
	}

	private void AssignTypeIfNeeded(ObjectEventInfo eventInfo)
	{
		if (tagMappings.TryGetValue(eventInfo.Source.Type, out var value))
		{
			eventInfo.Tag = value;
		}
		else if (requireTagWhenStaticAndActualTypesAreDifferent && eventInfo.Source.Value != null && eventInfo.Source.Type != eventInfo.Source.StaticType)
		{
			throw new YamlException("Cannot serialize type '" + eventInfo.Source.Type.FullName + "' where a '" + eventInfo.Source.StaticType.FullName + "' was expected because no tag mapping has been registered for '" + eventInfo.Source.Type.FullName + "', which means that it won't be possible to deserialize the document.\nRegister a tag mapping using the SerializerBuilder.WithTagMapping method.\n\nE.g: builder.WithTagMapping(\"!" + eventInfo.Source.Type.Name + "\", typeof(" + eventInfo.Source.Type.FullName + "));");
		}
	}

	private bool IsSpecialStringValue(string value)
	{
		if (value.Trim() == string.Empty)
		{
			return true;
		}
		return isSpecialStringValue_Regex?.IsMatch(value) ?? false;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.EventEmitters.WriterEventEmitter ----
namespace YamlDotNet.Serialization.EventEmitters
{
internal sealed class WriterEventEmitter : IEventEmitter
{
	void IEventEmitter.Emit(AliasEventInfo eventInfo, IEmitter emitter)
	{
		emitter.Emit(new AnchorAlias(eventInfo.Alias));
	}

	void IEventEmitter.Emit(ScalarEventInfo eventInfo, IEmitter emitter)
	{
		emitter.Emit(new Scalar(eventInfo.Anchor, eventInfo.Tag, eventInfo.RenderedValue, eventInfo.Style, eventInfo.IsPlainImplicit, eventInfo.IsQuotedImplicit));
	}

	void IEventEmitter.Emit(MappingStartEventInfo eventInfo, IEmitter emitter)
	{
		emitter.Emit(new MappingStart(eventInfo.Anchor, eventInfo.Tag, eventInfo.IsImplicit, eventInfo.Style));
	}

	void IEventEmitter.Emit(MappingEndEventInfo eventInfo, IEmitter emitter)
	{
		emitter.Emit(new MappingEnd());
	}

	void IEventEmitter.Emit(SequenceStartEventInfo eventInfo, IEmitter emitter)
	{
		emitter.Emit(new SequenceStart(eventInfo.Anchor, eventInfo.Tag, eventInfo.IsImplicit, eventInfo.Style));
	}

	void IEventEmitter.Emit(SequenceEndEventInfo eventInfo, IEmitter emitter)
	{
		emitter.Emit(new SequenceEnd());
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.Converters.DateTimeConverter ----
namespace YamlDotNet.Serialization.Converters
{
internal class DateTimeConverter : IYamlTypeConverter
{
	private readonly DateTimeKind kind;

	private readonly IFormatProvider provider;

	private readonly bool doubleQuotes;

	private readonly string[] formats;

	public DateTimeConverter(DateTimeKind kind = DateTimeKind.Utc, IFormatProvider? provider = null, bool doubleQuotes = false, params string[] formats)
	{
		this.kind = ((kind == DateTimeKind.Unspecified) ? DateTimeKind.Utc : kind);
		this.provider = provider ?? CultureInfo.InvariantCulture;
		this.doubleQuotes = doubleQuotes;
		this.formats = formats.DefaultIfEmpty<string>("G").ToArray();
	}

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

	public object ReadYaml(IParser parser, Type type)
	{
		return EnsureDateTimeKind(DateTime.ParseExact(parser.Consume<Scalar>().Value, style: (kind == DateTimeKind.Local) ? DateTimeStyles.AssumeLocal : DateTimeStyles.AssumeUniversal, formats: formats, provider: provider), kind);
	}

	public void WriteYaml(IEmitter emitter, object? value, Type type)
	{
		DateTime dateTime = (DateTime)value;
		string value2 = ((kind == DateTimeKind.Local) ? dateTime.ToLocalTime() : dateTime.ToUniversalTime()).ToString(formats.First(), provider);
		emitter.Emit(new Scalar(AnchorName.Empty, TagName.Empty, value2, doubleQuotes ? ScalarStyle.DoubleQuoted : ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: false));
	}

	private static DateTime EnsureDateTimeKind(DateTime dt, DateTimeKind kind)
	{
		if (dt.Kind == DateTimeKind.Local && kind == DateTimeKind.Utc)
		{
			return dt.ToUniversalTime();
		}
		if (dt.Kind == DateTimeKind.Utc && kind == DateTimeKind.Local)
		{
			return dt.ToLocalTime();
		}
		return dt;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.Converters.GuidConverter ----
namespace YamlDotNet.Serialization.Converters
{
internal class GuidConverter : IYamlTypeConverter
{
	private readonly bool jsonCompatible;

	public GuidConverter(bool jsonCompatible)
	{
		this.jsonCompatible = jsonCompatible;
	}

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

	public object ReadYaml(IParser parser, Type type)
	{
		return new Guid(parser.Consume<Scalar>().Value);
	}

	public void WriteYaml(IEmitter emitter, object? value, Type type)
	{
		Guid guid = (Guid)value;
		emitter.Emit(new Scalar(AnchorName.Empty, TagName.Empty, guid.ToString("D"), jsonCompatible ? ScalarStyle.DoubleQuoted : ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: false));
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.Converters.SystemTypeConverter ----
namespace YamlDotNet.Serialization.Converters
{
internal class SystemTypeConverter : IYamlTypeConverter
{
	public bool Accepts(Type type)
	{
		return typeof(Type).IsAssignableFrom(type);
	}

	public object ReadYaml(IParser parser, Type type)
	{
		return Type.GetType(parser.Consume<Scalar>().Value, throwOnError: true);
	}

	public void WriteYaml(IEmitter emitter, object? value, Type type)
	{
		Type type2 = (Type)value;
		emitter.Emit(new Scalar(AnchorName.Empty, TagName.Empty, type2.AssemblyQualifiedName, ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: false));
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.BufferedDeserialization.ITypeDiscriminatingNodeDeserializerOptions ----
namespace YamlDotNet.Serialization.BufferedDeserialization
{
internal interface ITypeDiscriminatingNodeDeserializerOptions
{
	void AddTypeDiscriminator(ITypeDiscriminator discriminator);

	void AddKeyValueTypeDiscriminator<T>(string discriminatorKey, IDictionary<string, Type> valueTypeMapping);

	void AddUniqueKeyTypeDiscriminator<T>(IDictionary<string, Type> uniqueKeyTypeMapping);
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.BufferedDeserialization.ParserBuffer ----
namespace YamlDotNet.Serialization.BufferedDeserialization
{
internal class ParserBuffer : IParser
{
	private readonly LinkedList<ParsingEvent> buffer;

	private LinkedListNode<ParsingEvent>? current;

	public ParsingEvent? Current => current?.Value;

	public ParserBuffer(IParser parserToBuffer, int maxDepth, int maxLength)
	{
		buffer = new LinkedList<ParsingEvent>();
		buffer.AddLast(parserToBuffer.Consume<MappingStart>());
		int num = 0;
		do
		{
			ParsingEvent parsingEvent = parserToBuffer.Consume<ParsingEvent>();
			num += parsingEvent.NestingIncrease;
			buffer.AddLast(parsingEvent);
			if (maxDepth > -1 && num > maxDepth)
			{
				throw new ArgumentOutOfRangeException("parserToBuffer", "Parser buffer exceeded max depth");
			}
			if (maxLength > -1 && buffer.Count > maxLength)
			{
				throw new ArgumentOutOfRangeException("parserToBuffer", "Parser buffer exceeded max length");
			}
		}
		while (num >= 0);
		current = buffer.First;
	}

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

	public void Reset()
	{
		current = buffer.First;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.BufferedDeserialization.TypeDiscriminatingNodeDeserializer ----
namespace YamlDotNet.Serialization.BufferedDeserialization
{
internal class TypeDiscriminatingNodeDeserializer : INodeDeserializer
{
	private readonly IList<INodeDeserializer> innerDeserializers;

	private readonly IList<ITypeDiscriminator> typeDiscriminators;

	private readonly int maxDepthToBuffer;

	private readonly int maxLengthToBuffer;

	public TypeDiscriminatingNodeDeserializer(IList<INodeDeserializer> innerDeserializers, IList<ITypeDiscriminator> typeDiscriminators, int maxDepthToBuffer, int maxLengthToBuffer)
	{
		this.innerDeserializers = innerDeserializers;
		this.typeDiscriminators = typeDiscriminators;
		this.maxDepthToBuffer = maxDepthToBuffer;
		this.maxLengthToBuffer = maxLengthToBuffer;
	}

	public bool Deserialize(IParser reader, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value)
	{
		if (!reader.Accept<MappingStart>(out var _))
		{
			value = null;
			return false;
		}
		IEnumerable<ITypeDiscriminator> enumerable = typeDiscriminators.Where((ITypeDiscriminator t) => t.BaseType.IsAssignableFrom(expectedType));
		if (!enumerable.Any())
		{
			value = null;
			return false;
		}
		Mark start = reader.Current.Start;
		Type expectedType2 = expectedType;
		ParserBuffer parserBuffer;
		try
		{
			parserBuffer = new ParserBuffer(reader, maxDepthToBuffer, maxLengthToBuffer);
		}
		catch (Exception innerException)
		{
			throw new YamlException(in start, reader.Current.End, "Failed to buffer yaml node", innerException);
		}
		try
		{
			foreach (ITypeDiscriminator item in enumerable)
			{
				parserBuffer.Reset();
				if (item.TryDiscriminate(parserBuffer, out Type suggestedType))
				{
					expectedType2 = suggestedType;
					break;
				}
			}
		}
		catch (Exception innerException2)
		{
			throw new YamlException(in start, reader.Current.End, "Failed to discriminate type", innerException2);
		}
		parserBuffer.Reset();
		foreach (INodeDeserializer innerDeserializer in innerDeserializers)
		{
			if (innerDeserializer.Deserialize(parserBuffer, expectedType2, nestedObjectDeserializer, out value))
			{
				return true;
			}
		}
		value = null;
		return false;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.BufferedDeserialization.TypeDiscriminatingNodeDeserializerOptions ----
namespace YamlDotNet.Serialization.BufferedDeserialization
{
internal class TypeDiscriminatingNodeDeserializerOptions : ITypeDiscriminatingNodeDeserializerOptions
{
	internal readonly List<ITypeDiscriminator> discriminators = new List<ITypeDiscriminator>();

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

	public void AddKeyValueTypeDiscriminator<T>(string discriminatorKey, IDictionary<string, Type> valueTypeMapping)
	{
		discriminators.Add(new KeyValueTypeDiscriminator(typeof(T), discriminatorKey, valueTypeMapping));
	}

	public void AddUniqueKeyTypeDiscriminator<T>(IDictionary<string, Type> uniqueKeyTypeMapping)
	{
		discriminators.Add(new UniqueKeyTypeDiscriminator(typeof(T), uniqueKeyTypeMapping));
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.BufferedDeserialization.TypeDiscriminators.ITypeDiscriminator ----
namespace YamlDotNet.Serialization.BufferedDeserialization.TypeDiscriminators
{
internal interface ITypeDiscriminator
{
	Type BaseType { get; }

	bool TryDiscriminate(IParser buffer, out Type? suggestedType);
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.BufferedDeserialization.TypeDiscriminators.KeyValueTypeDiscriminator ----
namespace YamlDotNet.Serialization.BufferedDeserialization.TypeDiscriminators
{
internal class KeyValueTypeDiscriminator : ITypeDiscriminator
{
	private readonly string targetKey;

	private readonly IDictionary<string, Type> typeMapping;

	public Type BaseType { get; private set; }

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

	public bool TryDiscriminate(IParser parser, out Type? suggestedType)
	{
		if (parser.TryFindMappingEntry((Scalar scalar2) => targetKey == scalar2.Value, out Scalar _, out ParsingEvent value) && value is Scalar scalar && typeMapping.TryGetValue(scalar.Value, out Type value2))
		{
			suggestedType = value2;
			return true;
		}
		suggestedType = null;
		return false;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Serialization.BufferedDeserialization.TypeDiscriminators.UniqueKeyTypeDiscriminator ----
namespace YamlDotNet.Serialization.BufferedDeserialization.TypeDiscriminators
{
internal class UniqueKeyTypeDiscriminator : ITypeDiscriminator
{
	private readonly IDictionary<string, Type> typeMapping;

	public Type BaseType { get; private set; }

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

	public bool TryDiscriminate(IParser parser, out Type? suggestedType)
	{
		if (parser.TryFindMappingEntry((Scalar scalar) => typeMapping.ContainsKey(scalar.Value), out Scalar key, out ParsingEvent _))
		{
			suggestedType = typeMapping[key.Value];
			return true;
		}
		suggestedType = null;
		return false;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.RepresentationModel.DocumentLoadingState ----
namespace YamlDotNet.RepresentationModel
{
internal class DocumentLoadingState
{
	private readonly IDictionary<AnchorName, YamlNode> anchors = new Dictionary<AnchorName, YamlNode>();

	private readonly IList<YamlNode> nodesWithUnresolvedAliases = new List<YamlNode>();

	public void AddAnchor(YamlNode node)
	{
		if (node.Anchor.IsEmpty)
		{
			throw new ArgumentException("The specified node does not have an anchor");
		}
		if (anchors.ContainsKey(node.Anchor))
		{
			anchors[node.Anchor] = node;
		}
		else
		{
			anchors.Add(node.Anchor, node);
		}
	}

	public YamlNode GetNode(AnchorName anchor, Mark start, Mark end)
	{
		if (anchors.TryGetValue(anchor, out YamlNode value))
		{
			return value;
		}
		throw new AnchorNotFoundException(in start, in end, $"The anchor '{anchor}' does not exists");
	}

	public bool TryGetNode(AnchorName anchor, [NotNullWhen(true)] out YamlNode? node)
	{
		return anchors.TryGetValue(anchor, out node);
	}

	public void AddNodeWithUnresolvedAliases(YamlNode node)
	{
		nodesWithUnresolvedAliases.Add(node);
	}

	public void ResolveAliases()
	{
		foreach (YamlNode nodesWithUnresolvedAlias in nodesWithUnresolvedAliases)
		{
			nodesWithUnresolvedAlias.ResolveAliases(this);
		}
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.RepresentationModel.EmitterState ----
namespace YamlDotNet.RepresentationModel
{
internal class EmitterState
{
	public HashSet<AnchorName> EmittedAnchors { get; } = new HashSet<AnchorName>();
}

}


// ---- MistrootTamer.dll :: YamlDotNet.RepresentationModel.IYamlVisitor ----
namespace YamlDotNet.RepresentationModel
{
internal interface IYamlVisitor
{
	void Visit(YamlStream stream);

	void Visit(YamlDocument document);

	void Visit(YamlScalarNode scalar);

	void Visit(YamlSequenceNode sequence);

	void Visit(YamlMappingNode mapping);
}

}


// ---- MistrootTamer.dll :: YamlDotNet.RepresentationModel.LibYamlEventStream ----
namespace YamlDotNet.RepresentationModel
{
internal class LibYamlEventStream
{
	private readonly IParser parser;

	public LibYamlEventStream(IParser iParser)
	{
		parser = iParser ?? throw new ArgumentNullException("iParser");
	}

	public void WriteTo(TextWriter textWriter)
	{
		while (parser.MoveNext())
		{
			ParsingEvent current = parser.Current;
			if (!(current is AnchorAlias anchorAlias))
			{
				if (!(current is DocumentEnd documentEnd))
				{
					if (!(current is DocumentStart documentStart))
					{
						if (!(current is MappingEnd))
						{
							if (!(current is MappingStart nodeEvent))
							{
								if (!(current is Scalar scalar))
								{
									if (!(current is SequenceEnd))
									{
										if (!(current is SequenceStart nodeEvent2))
										{
											if (!(current is StreamEnd))
											{
												if (current is StreamStart)
												{
													textWriter.Write("+STR");
												}
											}
											else
											{
												textWriter.Write("-STR");
											}
										}
										else
										{
											textWriter.Write("+SEQ");
											WriteAnchorAndTag(textWriter, nodeEvent2);
										}
									}
									else
									{
										textWriter.Write("-SEQ");
									}
								}
								else
								{
									textWriter.Write("=VAL");
									WriteAnchorAndTag(textWriter, scalar);
									switch (scalar.Style)
									{
									case ScalarStyle.DoubleQuoted:
										textWriter.Write(" \"");
										break;
									case ScalarStyle.SingleQuoted:
										textWriter.Write(" '");
										break;
									case ScalarStyle.Folded:
										textWriter.Write(" >");
										break;
									case ScalarStyle.Literal:
										textWriter.Write(" |");
										break;
									default:
										textWriter.Write(" :");
										break;
									}
									string value = scalar.Value;
									foreach (char c in value)
									{
										switch (c)
										{
										case '\b':
											textWriter.Write("\\b");
											break;
										case '\t':
											textWriter.Write("\\t");
											break;
										case '\n':
											textWriter.Write("\\n");
											break;
										case '\r':
											textWriter.Write("\\r");
											break;
										case '\\':
											textWriter.Write("\\\\");
											break;
										default:
											textWriter.Write(c);
											break;
										}
									}
								}
							}
							else
							{
								textWriter.Write("+MAP");
								WriteAnchorAndTag(textWriter, nodeEvent);
							}
						}
						else
						{
							textWriter.Write("-MAP");
						}
					}
					else
					{
						textWriter.Write("+DOC");
						if (!documentStart.IsImplicit)
						{
							textWriter.Write(" ---");
						}
					}
				}
				else
				{
					textWriter.Write("-DOC");
					if (!documentEnd.IsImplicit)
					{
						textWriter.Write(" ...");
					}
				}
			}
			else
			{
				textWriter.Write("=ALI *");
				textWriter.Write(anchorAlias.Value);
			}
			textWriter.WriteLine();
		}
	}

	private void WriteAnchorAndTag(TextWriter textWriter, NodeEvent nodeEvent)
	{
		if (!nodeEvent.Anchor.IsEmpty)
		{
			textWriter.Write(" &");
			textWriter.Write(nodeEvent.Anchor);
		}
		if (!nodeEvent.Tag.IsEmpty)
		{
			textWriter.Write(" <");
			textWriter.Write(nodeEvent.Tag.Value);
			textWriter.Write(">");
		}
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.RepresentationModel.YamlAliasNode ----
namespace YamlDotNet.RepresentationModel
{
internal class YamlAliasNode : YamlNode
{
	public override YamlNodeType NodeType => YamlNodeType.Alias;

	internal YamlAliasNode(AnchorName anchor)
	{
		base.Anchor = anchor;
	}

	internal override void ResolveAliases(DocumentLoadingState state)
	{
		throw new NotSupportedException("Resolving an alias on an alias node does not make sense");
	}

	internal override void Emit(IEmitter emitter, EmitterState state)
	{
		throw new NotSupportedException("A YamlAliasNode is an implementation detail and should never be saved.");
	}

	public override void Accept(IYamlVisitor visitor)
	{
		throw new NotSupportedException("A YamlAliasNode is an implementation detail and should never be visited.");
	}

	public override bool Equals(object? obj)
	{
		if (obj is YamlAliasNode yamlAliasNode && Equals(yamlAliasNode))
		{
			return object.Equals(base.Anchor, yamlAliasNode.Anchor);
		}
		return false;
	}

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

	internal override string ToString(RecursionLevel level)
	{
		return "*" + base.Anchor.ToString();
	}

	internal override IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level)
	{
		yield return this;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.RepresentationModel.YamlDocument ----
namespace YamlDotNet.RepresentationModel
{
internal class YamlDocument
{
	private class AnchorAssigningVisitor : YamlVisitorBase
	{
		private readonly HashSet<AnchorName> existingAnchors = new HashSet<AnchorName>();

		private readonly Dictionary<YamlNode, bool> visitedNodes = new Dictionary<YamlNode, bool>();

		public void AssignAnchors(YamlDocument document)
		{
			existingAnchors.Clear();
			visitedNodes.Clear();
			document.Accept(this);
			Random random = new Random();
			foreach (KeyValuePair<YamlNode, bool> visitedNode in visitedNodes)
			{
				if (!visitedNode.Value)
				{
					continue;
				}
				AnchorName anchorName;
				if (!visitedNode.Key.Anchor.IsEmpty && !existingAnchors.Contains(visitedNode.Key.Anchor))
				{
					anchorName = visitedNode.Key.Anchor;
				}
				else
				{
					do
					{
						anchorName = new AnchorName(random.Next().ToString(CultureInfo.InvariantCulture));
					}
					while (existingAnchors.Contains(anchorName));
				}
				existingAnchors.Add(anchorName);
				visitedNode.Key.Anchor = anchorName;
			}
		}

		private bool VisitNodeAndFindDuplicates(YamlNode node)
		{
			if (visitedNodes.TryGetValue(node, out var value))
			{
				if (!value)
				{
					visitedNodes[node] = true;
				}
				return !value;
			}
			visitedNodes.Add(node, value: false);
			return false;
		}

		public override void Visit(YamlScalarNode scalar)
		{
			VisitNodeAndFindDuplicates(scalar);
		}

		public override void Visit(YamlMappingNode mapping)
		{
			if (!VisitNodeAndFindDuplicates(mapping))
			{
				base.Visit(mapping);
			}
		}

		public override void Visit(YamlSequenceNode sequence)
		{
			if (!VisitNodeAndFindDuplicates(sequence))
			{
				base.Visit(sequence);
			}
		}
	}

	public YamlNode RootNode { get; private set; }

	public IEnumerable<YamlNode> AllNodes => RootNode.AllNodes;

	public YamlDocument(YamlNode rootNode)
	{
		RootNode = rootNode;
	}

	public YamlDocument(string rootNode)
	{
		RootNode = new YamlScalarNode(rootNode);
	}

	internal YamlDocument(IParser parser)
	{
		DocumentLoadingState documentLoadingState = new DocumentLoadingState();
		parser.Consume<DocumentStart>();
		DocumentEnd @event;
		while (!parser.TryConsume<DocumentEnd>(out @event))
		{
			RootNode = YamlNode.ParseNode(parser, documentLoadingState);
			if (RootNode is YamlAliasNode)
			{
				throw new YamlException("A document cannot contain only an alias");
			}
		}
		documentLoadingState.ResolveAliases();
		if (RootNode == null)
		{
			throw new ArgumentException("Atempted to parse an empty document");
		}
	}

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

	internal void Save(IEmitter emitter, bool assignAnchors = true)
	{
		if (assignAnchors)
		{
			AssignAnchors();
		}
		emitter.Emit(new DocumentStart());
		RootNode.Save(emitter, new EmitterState());
		emitter.Emit(new DocumentEnd(isImplicit: false));
	}

	public void Accept(IYamlVisitor visitor)
	{
		visitor.Visit(this);
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.RepresentationModel.YamlMappingNode ----
namespace YamlDotNet.RepresentationModel
{
internal sealed class YamlMappingNode : YamlNode, IEnumerable<KeyValuePair<YamlNode, YamlNode>>, IEnumerable, IYamlConvertible
{
	private readonly OrderedDictionary<YamlNode, YamlNode> children = new OrderedDictionary<YamlNode, YamlNode>();

	public IOrderedDictionary<YamlNode, YamlNode> Children => children;

	public MappingStyle Style { get; set; }

	public override YamlNodeType NodeType => YamlNodeType.Mapping;

	internal YamlMappingNode(IParser parser, DocumentLoadingState state)
	{
		Load(parser, state);
	}

	private void Load(IParser parser, DocumentLoadingState state)
	{
		MappingStart mappingStart = parser.Consume<MappingStart>();
		Load(mappingStart, state);
		Style = mappingStart.Style;
		bool flag = false;
		MappingEnd @event;
		while (!parser.TryConsume<MappingEnd>(out @event))
		{
			YamlNode yamlNode = YamlNode.ParseNode(parser, state);
			YamlNode yamlNode2 = YamlNode.ParseNode(parser, state);
			try
			{
				children.Add(yamlNode, yamlNode2);
			}
			catch (ArgumentException innerException)
			{
				throw new YamlException(yamlNode.Start, yamlNode.End, "Duplicate key", innerException);
			}
			flag = flag || yamlNode is YamlAliasNode || yamlNode2 is YamlAliasNode;
		}
		if (flag)
		{
			state.AddNodeWithUnresolvedAliases(this);
		}
	}

	public YamlMappingNode()
	{
	}

	public YamlMappingNode(params KeyValuePair<YamlNode, YamlNode>[] children)
		: this((IEnumerable<KeyValuePair<YamlNode, YamlNode>>)children)
	{
	}

	public YamlMappingNode(IEnumerable<KeyValuePair<YamlNode, YamlNode>> children)
	{
		foreach (KeyValuePair<YamlNode, YamlNode> child in children)
		{
			this.children.Add(child);
		}
	}

	public YamlMappingNode(params YamlNode[] children)
		: this((IEnumerable<YamlNode>)children)
	{
	}

	public YamlMappingNode(IEnumerable<YamlNode> children)
	{
		using IEnumerator<YamlNode> enumerator = children.GetEnumerator();
		while (enumerator.MoveNext())
		{
			YamlNode current = enumerator.Current;
			if (!enumerator.MoveNext())
			{
				throw new ArgumentException("When constructing a mapping node with a sequence, the number of elements of the sequence must be even.");
			}
			Add(current, enumerator.Current);
		}
	}

	public void Add(YamlNode key, YamlNode value)
	{
		children.Add(key, value);
	}

	public void Add(string key, YamlNode value)
	{
		children.Add(new YamlScalarNode(key), value);
	}

	public void Add(YamlNode key, string value)
	{
		children.Add(key, new YamlScalarNode(value));
	}

	public void Add(string key, string value)
	{
		children.Add(new YamlScalarNode(key), new YamlScalarNode(value));
	}

	internal override void ResolveAliases(DocumentLoadingState state)
	{
		Dictionary<YamlNode, YamlNode> dictionary = null;
		Dictionary<YamlNode, YamlNode> dictionary2 = null;
		foreach (KeyValuePair<YamlNode, YamlNode> child in children)
		{
			if (child.Key is YamlAliasNode)
			{
				if (dictionary == null)
				{
					dictionary = new Dictionary<YamlNode, YamlNode>();
				}
				dictionary.Add(child.Key, state.GetNode(child.Key.Anchor, child.Key.Start, child.Key.End));
			}
			if (child.Value is YamlAliasNode)
			{
				if (dictionary2 == null)
				{
					dictionary2 = new Dictionary<YamlNode, YamlNode>();
				}
				dictionary2.Add(child.Key, state.GetNode(child.Value.Anchor, child.Value.Start, child.Value.End));
			}
		}
		if (dictionary2 != null)
		{
			foreach (KeyValuePair<YamlNode, YamlNode> item in dictionary2)
			{
				children[item.Key] = item.Value;
			}
		}
		if (dictionary == null)
		{
			return;
		}
		foreach (KeyValuePair<YamlNode, YamlNode> item2 in dictionary)
		{
			YamlNode value = children[item2.Key];
			children.Remove(item2.Key);
			children.Add(item2.Value, value);
		}
	}

	internal override void Emit(IEmitter emitter, EmitterState state)
	{
		emitter.Emit(new MappingStart(base.Anchor, base.Tag, isImplicit: true, Style));
		foreach (KeyValuePair<YamlNode, YamlNode> child in children)
		{
			child.Key.Save(emitter, state);
			child.Value.Save(emitter, state);
		}
		emitter.Emit(new MappingEnd());
	}

	public override void Accept(IYamlVisitor visitor)
	{
		visitor.Visit(this);
	}

	public override bool Equals(object? obj)
	{
		if (!(obj is YamlMappingNode yamlMappingNode) || !object.Equals(base.Tag, yamlMappingNode.Tag) || children.Count != yamlMappingNode.children.Count)
		{
			return false;
		}
		foreach (KeyValuePair<YamlNode, YamlNode> child in children)
		{
			if (!yamlMappingNode.children.TryGetValue(child.Key, out YamlNode value) || !object.Equals(child.Value, value))
			{
				return false;
			}
		}
		return true;
	}

	public override int GetHashCode()
	{
		int num = base.GetHashCode();
		foreach (KeyValuePair<YamlNode, YamlNode> child in children)
		{
			num = YamlDotNet.Core.HashCode.CombineHashCodes(num, child.Key);
			num = YamlDotNet.Core.HashCode.CombineHashCodes(num, child.Value);
		}
		return num;
	}

	internal override IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level)
	{
		level.Increment();
		yield return this;
		foreach (KeyValuePair<YamlNode, YamlNode> child in children)
		{
			foreach (YamlNode item in child.Key.SafeAllNodes(level))
			{
				yield return item;
			}
			foreach (YamlNode item2 in child.Value.SafeAllNodes(level))
			{
				yield return item2;
			}
		}
		level.Decrement();
	}

	internal override string ToString(RecursionLevel level)
	{
		if (!level.TryIncrement())
		{
			return "WARNING! INFINITE RECURSION!";
		}
		StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
		try
		{
			StringBuilder builder = builderWrapper.Builder;
			builder.Append("{ ");
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				if (builder.Length > 2)
				{
					builder.Append(", ");
				}
				builder.Append("{ ").Append(child.Key.ToString(level)).Append(", ")
					.Append(child.Value.ToString(level))
					.Append(" }");
			}
			builder.Append(" }");
			level.Decrement();
			return builder.ToString();
		}
		finally
		{
			((IDisposable)builderWrapper/*cast due to constrained. prefix*//*cast due to constrained. prefix*/).Dispose();
		}
	}

	public IEnumerator<KeyValuePair<YamlNode, YamlNode>> GetEnumerator()
	{
		return children.GetEnumerator();
	}

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

	void IYamlConvertible.Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer)
	{
		Load(parser, new DocumentLoadingState());
	}

	void IYamlConvertible.Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer)
	{
		Emit(emitter, new EmitterState());
	}

	public static YamlMappingNode FromObject(object mapping)
	{
		if (mapping == null)
		{
			throw new ArgumentNullException("mapping");
		}
		YamlMappingNode yamlMappingNode = new YamlMappingNode();
		foreach (PropertyInfo publicProperty in mapping.GetType().GetPublicProperties())
		{
			if (publicProperty.CanRead && publicProperty.GetGetMethod(nonPublic: false).GetParameters().Length == 0)
			{
				object value = publicProperty.GetValue(mapping, null);
				YamlNode yamlNode = value as YamlNode;
				if (yamlNode == null)
				{
					yamlNode = Convert.ToString(value) ?? string.Empty;
				}
				yamlMappingNode.Add(publicProperty.Name, yamlNode);
			}
		}
		return yamlMappingNode;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.RepresentationModel.YamlNode ----
namespace YamlDotNet.RepresentationModel
{
internal abstract class YamlNode
{
	private const int MaximumRecursionLevel = 1000;

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

	public AnchorName Anchor { get; set; }

	public TagName Tag { get; set; }

	public Mark Start { get; private set; } = Mark.Empty;

	public Mark End { get; private set; } = Mark.Empty;

	public IEnumerable<YamlNode> AllNodes
	{
		get
		{
			RecursionLevel level = new RecursionLevel(1000);
			return SafeAllNodes(level);
		}
	}

	public abstract YamlNodeType NodeType { get; }

	public YamlNode this[int index]
	{
		get
		{
			if (!(this is YamlSequenceNode yamlSequenceNode))
			{
				throw new ArgumentException($"Accessed '{NodeType}' with an invalid index: {index}. Only Sequences can be indexed by number.");
			}
			return yamlSequenceNode.Children[index];
		}
	}

	public YamlNode this[YamlNode key]
	{
		get
		{
			if (!(this is YamlMappingNode yamlMappingNode))
			{
				throw new ArgumentException($"Accessed '{NodeType}' with an invalid index: {key}. Only Mappings can be indexed by key.");
			}
			return yamlMappingNode.Children[key];
		}
	}

	internal void Load(NodeEvent yamlEvent, DocumentLoadingState state)
	{
		Tag = yamlEvent.Tag;
		if (!yamlEvent.Anchor.IsEmpty)
		{
			Anchor = yamlEvent.Anchor;
			state.AddAnchor(this);
		}
		Start = yamlEvent.Start;
		End = yamlEvent.End;
	}

	internal static YamlNode ParseNode(IParser parser, DocumentLoadingState state)
	{
		if (parser.Accept<Scalar>(out var _))
		{
			return new YamlScalarNode(parser, state);
		}
		if (parser.Accept<SequenceStart>(out var _))
		{
			return new YamlSequenceNode(parser, state);
		}
		if (parser.Accept<MappingStart>(out var _))
		{
			return new YamlMappingNode(parser, state);
		}
		if (parser.TryConsume<AnchorAlias>(out var event4))
		{
			if (!state.TryGetNode(event4.Value, out YamlNode node))
			{
				return new YamlAliasNode(event4.Value);
			}
			return node;
		}
		throw new ArgumentException("The current event is of an unsupported type.", "parser");
	}

	internal abstract void ResolveAliases(DocumentLoadingState state);

	internal void Save(IEmitter emitter, EmitterState state)
	{
		if (!Anchor.IsEmpty && !state.EmittedAnchors.Add(Anchor))
		{
			emitter.Emit(new AnchorAlias(Anchor));
		}
		else
		{
			Emit(emitter, state);
		}
	}

	internal abstract void Emit(IEmitter emitter, EmitterState state);

	public abstract void Accept(IYamlVisitor visitor);

	public override string ToString()
	{
		RecursionLevel recursionLevel = new RecursionLevel(1000);
		return ToString(recursionLevel);
	}

	internal abstract string ToString(RecursionLevel level);

	internal abstract IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level);

	public static implicit operator YamlNode(string value)
	{
		return new YamlScalarNode(value);
	}

	public static implicit operator YamlNode(string[] sequence)
	{
		return new YamlSequenceNode(((IEnumerable<string>)sequence).Select((Func<string, YamlNode>)((string i) => i)));
	}

	public static explicit operator string?(YamlNode node)
	{
		if (!(node is YamlScalarNode yamlScalarNode))
		{
			throw new ArgumentException($"Attempted to convert a '{node.NodeType}' to string. This conversion is valid only for Scalars.");
		}
		return yamlScalarNode.Value;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.RepresentationModel.YamlNodeIdentityEqualityComparer ----
namespace YamlDotNet.RepresentationModel
{
internal sealed class YamlNodeIdentityEqualityComparer : IEqualityComparer<YamlNode>
{
	public bool Equals([AllowNull] YamlNode x, [AllowNull] YamlNode y)
	{
		return x == y;
	}

	public int GetHashCode(YamlNode obj)
	{
		return obj.GetHashCode();
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.RepresentationModel.YamlNodeType ----
namespace YamlDotNet.RepresentationModel
{
internal enum YamlNodeType
{
	Alias,
	Mapping,
	Scalar,
	Sequence
}

}


// ---- MistrootTamer.dll :: YamlDotNet.RepresentationModel.YamlScalarNode ----
namespace YamlDotNet.RepresentationModel
{
[DebuggerDisplay("{Value}")]
internal sealed class YamlScalarNode : YamlNode, IYamlConvertible
{
	public string? Value { get; set; }

	public ScalarStyle Style { get; set; }

	public override YamlNodeType NodeType => YamlNodeType.Scalar;

	internal YamlScalarNode(IParser parser, DocumentLoadingState state)
	{
		Load(parser, state);
	}

	private void Load(IParser parser, DocumentLoadingState state)
	{
		Scalar scalar = parser.Consume<Scalar>();
		Load(scalar, state);
		Value = scalar.Value;
		Style = scalar.Style;
	}

	public YamlScalarNode()
	{
	}

	public YamlScalarNode(string? value)
	{
		Value = value;
	}

	internal override void ResolveAliases(DocumentLoadingState state)
	{
		throw new NotSupportedException("Resolving an alias on a scalar node does not make sense");
	}

	internal override void Emit(IEmitter emitter, EmitterState state)
	{
		emitter.Emit(new Scalar(base.Anchor, base.Tag, Value ?? string.Empty, Style, base.Tag.IsEmpty, isQuotedImplicit: false));
	}

	public override void Accept(IYamlVisitor visitor)
	{
		visitor.Visit(this);
	}

	public override bool Equals(object? obj)
	{
		if (obj is YamlScalarNode yamlScalarNode && object.Equals(base.Tag, yamlScalarNode.Tag))
		{
			return object.Equals(Value, yamlScalarNode.Value);
		}
		return false;
	}

	public override int GetHashCode()
	{
		return YamlDotNet.Core.HashCode.CombineHashCodes(base.Tag.GetHashCode(), Value);
	}

	public static explicit operator string?(YamlScalarNode value)
	{
		return value.Value;
	}

	internal override string ToString(RecursionLevel level)
	{
		return Value ?? string.Empty;
	}

	internal override IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level)
	{
		yield return this;
	}

	void IYamlConvertible.Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer)
	{
		Load(parser, new DocumentLoadingState());
	}

	void IYamlConvertible.Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer)
	{
		Emit(emitter, new EmitterState());
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.RepresentationModel.YamlSequenceNode ----
namespace YamlDotNet.RepresentationModel
{
[DebuggerDisplay("Count = {children.Count}")]
internal sealed class YamlSequenceNode : YamlNode, IEnumerable<YamlNode>, IEnumerable, IYamlConvertible
{
	private readonly IList<YamlNode> children = new List<YamlNode>();

	public IList<YamlNode> Children => children;

	public SequenceStyle Style { get; set; }

	public override YamlNodeType NodeType => YamlNodeType.Sequence;

	internal YamlSequenceNode(IParser parser, DocumentLoadingState state)
	{
		Load(parser, state);
	}

	private void Load(IParser parser, DocumentLoadingState state)
	{
		SequenceStart sequenceStart = parser.Consume<SequenceStart>();
		Load(sequenceStart, state);
		Style = sequenceStart.Style;
		bool flag = false;
		SequenceEnd @event;
		while (!parser.TryConsume<SequenceEnd>(out @event))
		{
			YamlNode yamlNode = YamlNode.ParseNode(parser, state);
			children.Add(yamlNode);
			flag = flag || yamlNode is YamlAliasNode;
		}
		if (flag)
		{
			state.AddNodeWithUnresolvedAliases(this);
		}
	}

	public YamlSequenceNode()
	{
	}

	public YamlSequenceNode(params YamlNode[] children)
		: this((IEnumerable<YamlNode>)children)
	{
	}

	public YamlSequenceNode(IEnumerable<YamlNode> children)
	{
		foreach (YamlNode child in children)
		{
			this.children.Add(child);
		}
	}

	public void Add(YamlNode child)
	{
		children.Add(child);
	}

	public void Add(string child)
	{
		children.Add(new YamlScalarNode(child));
	}

	internal override void ResolveAliases(DocumentLoadingState state)
	{
		for (int i = 0; i < children.Count; i++)
		{
			if (children[i] is YamlAliasNode)
			{
				children[i] = state.GetNode(children[i].Anchor, children[i].Start, children[i].End);
			}
		}
	}

	internal override void Emit(IEmitter emitter, EmitterState state)
	{
		emitter.Emit(new SequenceStart(base.Anchor, base.Tag, base.Tag.IsEmpty, Style));
		foreach (YamlNode child in children)
		{
			child.Save(emitter, state);
		}
		emitter.Emit(new SequenceEnd());
	}

	public override void Accept(IYamlVisitor visitor)
	{
		visitor.Visit(this);
	}

	public override bool Equals(object? obj)
	{
		if (!(obj is YamlSequenceNode yamlSequenceNode) || !object.Equals(base.Tag, yamlSequenceNode.Tag) || children.Count != yamlSequenceNode.children.Count)
		{
			return false;
		}
		for (int i = 0; i < children.Count; i++)
		{
			if (!object.Equals(children[i], yamlSequenceNode.children[i]))
			{
				return false;
			}
		}
		return true;
	}

	public override int GetHashCode()
	{
		int h = 0;
		foreach (YamlNode child in children)
		{
			h = YamlDotNet.Core.HashCode.CombineHashCodes(h, child);
		}
		return YamlDotNet.Core.HashCode.CombineHashCodes(h, base.Tag);
	}

	internal override IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level)
	{
		level.Increment();
		yield return this;
		foreach (YamlNode child in children)
		{
			foreach (YamlNode item in child.SafeAllNodes(level))
			{
				yield return item;
			}
		}
		level.Decrement();
	}

	internal override string ToString(RecursionLevel level)
	{
		if (!level.TryIncrement())
		{
			return "WARNING! INFINITE RECURSION!";
		}
		StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
		try
		{
			StringBuilder builder = builderWrapper.Builder;
			builder.Append("[ ");
			foreach (YamlNode child in children)
			{
				if (builder.Length > 2)
				{
					builder.Append(", ");
				}
				builder.Append(child.ToString(level));
			}
			builder.Append(" ]");
			level.Decrement();
			return builder.ToString();
		}
		finally
		{
			((IDisposable)builderWrapper/*cast due to constrained. prefix*//*cast due to constrained. prefix*/).Dispose();
		}
	}

	public IEnumerator<YamlNode> GetEnumerator()
	{
		return Children.GetEnumerator();
	}

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

	void IYamlConvertible.Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer)
	{
		Load(parser, new DocumentLoadingState());
	}

	void IYamlConvertible.Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer)
	{
		Emit(emitter, new EmitterState());
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.RepresentationModel.YamlStream ----
namespace YamlDotNet.RepresentationModel
{
internal class YamlStream : IEnumerable<YamlDocument>, IEnumerable
{
	private readonly IList<YamlDocument> documents = new List<YamlDocument>();

	public IList<YamlDocument> Documents => documents;

	public YamlStream()
	{
	}

	public YamlStream(params YamlDocument[] documents)
		: this((IEnumerable<YamlDocument>)documents)
	{
	}

	public YamlStream(IEnumerable<YamlDocument> documents)
	{
		foreach (YamlDocument document in documents)
		{
			this.documents.Add(document);
		}
	}

	public void Add(YamlDocument document)
	{
		documents.Add(document);
	}

	public void Load(TextReader input)
	{
		Load(new Parser(input));
	}

	public void Load(IParser parser)
	{
		documents.Clear();
		parser.Consume<StreamStart>();
		StreamEnd @event;
		while (!parser.TryConsume<StreamEnd>(out @event))
		{
			YamlDocument item = new YamlDocument(parser);
			documents.Add(item);
		}
	}

	public void Save(TextWriter output)
	{
		Save(output, assignAnchors: true);
	}

	public void Save(TextWriter output, bool assignAnchors)
	{
		Save(new Emitter(output), assignAnchors);
	}

	public void Save(IEmitter emitter, bool assignAnchors)
	{
		emitter.Emit(new StreamStart());
		foreach (YamlDocument document in documents)
		{
			document.Save(emitter, assignAnchors);
		}
		emitter.Emit(new StreamEnd());
	}

	public void Accept(IYamlVisitor visitor)
	{
		visitor.Visit(this);
	}

	public IEnumerator<YamlDocument> GetEnumerator()
	{
		return documents.GetEnumerator();
	}

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

}


// ---- MistrootTamer.dll :: YamlDotNet.RepresentationModel.YamlVisitor ----
namespace YamlDotNet.RepresentationModel
{
[Obsolete("Use YamlVisitorBase")]
internal abstract class YamlVisitor : IYamlVisitor
{
	protected virtual void Visit(YamlStream stream)
	{
	}

	protected virtual void Visited(YamlStream stream)
	{
	}

	protected virtual void Visit(YamlDocument document)
	{
	}

	protected virtual void Visited(YamlDocument document)
	{
	}

	protected virtual void Visit(YamlScalarNode scalar)
	{
	}

	protected virtual void Visited(YamlScalarNode scalar)
	{
	}

	protected virtual void Visit(YamlSequenceNode sequence)
	{
	}

	protected virtual void Visited(YamlSequenceNode sequence)
	{
	}

	protected virtual void Visit(YamlMappingNode mapping)
	{
	}

	protected virtual void Visited(YamlMappingNode mapping)
	{
	}

	protected virtual void VisitChildren(YamlStream stream)
	{
		foreach (YamlDocument document in stream.Documents)
		{
			document.Accept(this);
		}
	}

	protected virtual void VisitChildren(YamlDocument document)
	{
		if (document.RootNode != null)
		{
			document.RootNode.Accept(this);
		}
	}

	protected virtual void VisitChildren(YamlSequenceNode sequence)
	{
		foreach (YamlNode child in sequence.Children)
		{
			child.Accept(this);
		}
	}

	protected virtual void VisitChildren(YamlMappingNode mapping)
	{
		foreach (KeyValuePair<YamlNode, YamlNode> child in mapping.Children)
		{
			child.Key.Accept(this);
			child.Value.Accept(this);
		}
	}

	void IYamlVisitor.Visit(YamlStream stream)
	{
		Visit(stream);
		VisitChildren(stream);
		Visited(stream);
	}

	void IYamlVisitor.Visit(YamlDocument document)
	{
		Visit(document);
		VisitChildren(document);
		Visited(document);
	}

	void IYamlVisitor.Visit(YamlScalarNode scalar)
	{
		Visit(scalar);
		Visited(scalar);
	}

	void IYamlVisitor.Visit(YamlSequenceNode sequence)
	{
		Visit(sequence);
		VisitChildren(sequence);
		Visited(sequence);
	}

	void IYamlVisitor.Visit(YamlMappingNode mapping)
	{
		Visit(mapping);
		VisitChildren(mapping);
		Visited(mapping);
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.RepresentationModel.YamlVisitorBase ----
namespace YamlDotNet.RepresentationModel
{
internal abstract class YamlVisitorBase : IYamlVisitor
{
	public virtual void Visit(YamlStream stream)
	{
		VisitChildren(stream);
	}

	public virtual void Visit(YamlDocument document)
	{
		VisitChildren(document);
	}

	public virtual void Visit(YamlScalarNode scalar)
	{
	}

	public virtual void Visit(YamlSequenceNode sequence)
	{
		VisitChildren(sequence);
	}

	public virtual void Visit(YamlMappingNode mapping)
	{
		VisitChildren(mapping);
	}

	protected virtual void VisitPair(YamlNode key, YamlNode value)
	{
		key.Accept(this);
		value.Accept(this);
	}

	protected virtual void VisitChildren(YamlStream stream)
	{
		foreach (YamlDocument document in stream.Documents)
		{
			document.Accept(this);
		}
	}

	protected virtual void VisitChildren(YamlDocument document)
	{
		if (document.RootNode != null)
		{
			document.RootNode.Accept(this);
		}
	}

	protected virtual void VisitChildren(YamlSequenceNode sequence)
	{
		foreach (YamlNode child in sequence.Children)
		{
			child.Accept(this);
		}
	}

	protected virtual void VisitChildren(YamlMappingNode mapping)
	{
		foreach (KeyValuePair<YamlNode, YamlNode> child in mapping.Children)
		{
			VisitPair(child.Key, child.Value);
		}
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Helpers.ConcurrentObjectPool`1 ----
namespace YamlDotNet.Helpers
{
[DebuggerStepThrough]
internal sealed class ConcurrentObjectPool<T> where T : class
{
	[DebuggerDisplay("{value,nq}")]
	private struct Element
	{
		internal T? value;
	}

	internal delegate T Factory();

	private T? firstItem;

	private readonly Element[] items;

	private readonly Factory factory;

	internal ConcurrentObjectPool(Factory factory)
		: this(factory, Environment.ProcessorCount * 2)
	{
	}

	internal ConcurrentObjectPool(Factory factory, int size)
	{
		this.factory = factory;
		items = new Element[size - 1];
	}

	private T CreateInstance()
	{
		return factory();
	}

	internal T Allocate()
	{
		T val = firstItem;
		if (val == null || val != Interlocked.CompareExchange(ref firstItem, null, val))
		{
			val = AllocateSlow();
		}
		return val;
	}

	private T AllocateSlow()
	{
		Element[] array = items;
		for (int i = 0; i < array.Length; i++)
		{
			T value = array[i].value;
			if (value != null && value == Interlocked.CompareExchange(ref array[i].value, null, value))
			{
				return value;
			}
		}
		return CreateInstance();
	}

	internal void Free(T obj)
	{
		if (firstItem == null)
		{
			firstItem = obj;
		}
		else
		{
			FreeSlow(obj);
		}
	}

	private void FreeSlow(T obj)
	{
		Element[] array = items;
		for (int i = 0; i < array.Length; i++)
		{
			if (array[i].value == null)
			{
				array[i].value = obj;
				break;
			}
		}
	}

	[Conditional("DEBUG")]
	private void Validate(object obj)
	{
		Element[] array = items;
		for (int i = 0; i < array.Length && array[i].value != null; i++)
		{
		}
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Helpers.ExpressionExtensions ----
namespace YamlDotNet.Helpers
{
internal static class ExpressionExtensions
{
	public static PropertyInfo AsProperty(this LambdaExpression propertyAccessor)
	{
		PropertyInfo propertyInfo = TryGetMemberExpression<PropertyInfo>(propertyAccessor);
		if (propertyInfo == null)
		{
			throw new ArgumentException("Expected a lambda expression in the form: x => x.SomeProperty", "propertyAccessor");
		}
		return propertyInfo;
	}

	[return: MaybeNull]
	private static TMemberInfo TryGetMemberExpression<TMemberInfo>(LambdaExpression lambdaExpression) where TMemberInfo : MemberInfo
	{
		if (lambdaExpression.Parameters.Count != 1)
		{
			return null;
		}
		Expression expression = lambdaExpression.Body;
		if (expression is UnaryExpression unaryExpression)
		{
			if (unaryExpression.NodeType != ExpressionType.Convert)
			{
				return null;
			}
			expression = unaryExpression.Operand;
		}
		if (expression is MemberExpression memberExpression)
		{
			if (memberExpression.Expression != lambdaExpression.Parameters[0])
			{
				return null;
			}
			return memberExpression.Member as TMemberInfo;
		}
		return null;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Helpers.GenericCollectionToNonGenericAdapter`1 ----
namespace YamlDotNet.Helpers
{
internal sealed class GenericCollectionToNonGenericAdapter<T> : IList, ICollection, IEnumerable
{
	private readonly ICollection<T> genericCollection;

	public bool IsFixedSize
	{
		get
		{
			throw new NotSupportedException();
		}
	}

	public bool IsReadOnly
	{
		get
		{
			throw new NotSupportedException();
		}
	}

	public object? this[int index]
	{
		get
		{
			throw new NotSupportedException();
		}
		set
		{
			((IList<T>)genericCollection)[index] = (T)value;
		}
	}

	public int Count
	{
		get
		{
			throw new NotSupportedException();
		}
	}

	public bool IsSynchronized
	{
		get
		{
			throw new NotSupportedException();
		}
	}

	public object SyncRoot
	{
		get
		{
			throw new NotSupportedException();
		}
	}

	public GenericCollectionToNonGenericAdapter(ICollection<T> genericCollection)
	{
		this.genericCollection = genericCollection ?? throw new ArgumentNullException("genericCollection");
	}

	public int Add(object? value)
	{
		int count = genericCollection.Count;
		genericCollection.Add((T)value);
		return count;
	}

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

	public bool Contains(object? value)
	{
		throw new NotSupportedException();
	}

	public int IndexOf(object? value)
	{
		throw new NotSupportedException();
	}

	public void Insert(int index, object? value)
	{
		throw new NotSupportedException();
	}

	public void Remove(object? value)
	{
		throw new NotSupportedException();
	}

	public void RemoveAt(int index)
	{
		throw new NotSupportedException();
	}

	public void CopyTo(Array array, int index)
	{
		throw new NotSupportedException();
	}

	public IEnumerator GetEnumerator()
	{
		return genericCollection.GetEnumerator();
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Helpers.GenericDictionaryToNonGenericAdapter`2 ----
namespace YamlDotNet.Helpers
{
internal sealed class GenericDictionaryToNonGenericAdapter<TKey, TValue> : IDictionary, ICollection, IEnumerable where TKey : notnull
{
	private class DictionaryEnumerator : IDictionaryEnumerator, IEnumerator
	{
		private readonly IEnumerator<KeyValuePair<TKey, TValue>> enumerator;

		public DictionaryEntry Entry => new DictionaryEntry(Key, Value);

		public object Key => enumerator.Current.Key;

		public object? Value => enumerator.Current.Value;

		public object Current => Entry;

		public DictionaryEnumerator(IEnumerator<KeyValuePair<TKey, TValue>> enumerator)
		{
			this.enumerator = enumerator;
		}

		public bool MoveNext()
		{
			return enumerator.MoveNext();
		}

		public void Reset()
		{
			enumerator.Reset();
		}
	}

	private readonly IDictionary<TKey, TValue> genericDictionary;

	public bool IsFixedSize
	{
		get
		{
			throw new NotSupportedException();
		}
	}

	public bool IsReadOnly
	{
		get
		{
			throw new NotSupportedException();
		}
	}

	public ICollection Keys
	{
		get
		{
			throw new NotSupportedException();
		}
	}

	public ICollection Values
	{
		get
		{
			throw new NotSupportedException();
		}
	}

	public object? this[object key]
	{
		get
		{
			throw new NotSupportedException();
		}
		set
		{
			genericDictionary[(TKey)key] = (TValue)value;
		}
	}

	public int Count
	{
		get
		{
			throw new NotSupportedException();
		}
	}

	public bool IsSynchronized
	{
		get
		{
			throw new NotSupportedException();
		}
	}

	public object SyncRoot
	{
		get
		{
			throw new NotSupportedException();
		}
	}

	public GenericDictionaryToNonGenericAdapter(IDictionary<TKey, TValue> genericDictionary)
	{
		this.genericDictionary = genericDictionary ?? throw new ArgumentNullException("genericDictionary");
	}

	public void Add(object key, object? value)
	{
		throw new NotSupportedException();
	}

	public void Clear()
	{
		throw new NotSupportedException();
	}

	public bool Contains(object key)
	{
		throw new NotSupportedException();
	}

	public IDictionaryEnumerator GetEnumerator()
	{
		return new DictionaryEnumerator(genericDictionary.GetEnumerator());
	}

	public void Remove(object key)
	{
		throw new NotSupportedException();
	}

	public void CopyTo(Array array, int index)
	{
		throw new NotSupportedException();
	}

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

}


// ---- MistrootTamer.dll :: YamlDotNet.Helpers.IOrderedDictionary`2 ----
namespace YamlDotNet.Helpers
{
internal interface IOrderedDictionary<TKey, TValue> : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable where TKey : notnull
{
	KeyValuePair<TKey, TValue> this[int index] { get; set; }

	void Insert(int index, TKey key, TValue value);

	void RemoveAt(int index);
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Helpers.NumberExtensions ----
namespace YamlDotNet.Helpers
{
internal static class NumberExtensions
{
	public static bool IsPowerOfTwo(this int value)
	{
		return (value & (value - 1)) == 0;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Helpers.OrderedDictionary`2 ----
namespace YamlDotNet.Helpers
{
[Serializable]
internal sealed class OrderedDictionary<TKey, TValue> : IOrderedDictionary<TKey, TValue>, IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable where TKey : notnull
{
	private class KeyCollection : ICollection<TKey>, IEnumerable<TKey>, IEnumerable
	{
		private readonly OrderedDictionary<TKey, TValue> orderedDictionary;

		public int Count => orderedDictionary.list.Count;

		public bool IsReadOnly => true;

		public void Add(TKey item)
		{
			throw new NotSupportedException();
		}

		public void Clear()
		{
			throw new NotSupportedException();
		}

		public bool Contains(TKey item)
		{
			return orderedDictionary.dictionary.Keys.Contains(item);
		}

		public KeyCollection(OrderedDictionary<TKey, TValue> orderedDictionary)
		{
			this.orderedDictionary = orderedDictionary;
		}

		public void CopyTo(TKey[] array, int arrayIndex)
		{
			for (int i = 0; i < orderedDictionary.list.Count; i++)
			{
				array[i] = orderedDictionary.list[i + arrayIndex].Key;
			}
		}

		public IEnumerator<TKey> GetEnumerator()
		{
			return orderedDictionary.list.Select((KeyValuePair<TKey, TValue> kvp) => kvp.Key).GetEnumerator();
		}

		public bool Remove(TKey item)
		{
			throw new NotSupportedException();
		}

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

	private class ValueCollection : ICollection<TValue>, IEnumerable<TValue>, IEnumerable
	{
		private readonly OrderedDictionary<TKey, TValue> orderedDictionary;

		public int Count => orderedDictionary.list.Count;

		public bool IsReadOnly => true;

		public void Add(TValue item)
		{
			throw new NotSupportedException();
		}

		public void Clear()
		{
			throw new NotSupportedException();
		}

		public bool Contains(TValue item)
		{
			return orderedDictionary.dictionary.Values.Contains(item);
		}

		public ValueCollection(OrderedDictionary<TKey, TValue> orderedDictionary)
		{
			this.orderedDictionary = orderedDictionary;
		}

		public void CopyTo(TValue[] array, int arrayIndex)
		{
			for (int i = 0; i < orderedDictionary.list.Count; i++)
			{
				array[i] = orderedDictionary.list[i + arrayIndex].Value;
			}
		}

		public IEnumerator<TValue> GetEnumerator()
		{
			return orderedDictionary.list.Select((KeyValuePair<TKey, TValue> kvp) => kvp.Value).GetEnumerator();
		}

		public bool Remove(TValue item)
		{
			throw new NotSupportedException();
		}

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

	[NonSerialized]
	private Dictionary<TKey, TValue> dictionary;

	private readonly List<KeyValuePair<TKey, TValue>> list;

	private readonly IEqualityComparer<TKey> comparer;

	public TValue this[TKey key]
	{
		get
		{
			return dictionary[key];
		}
		set
		{
			if (dictionary.ContainsKey(key))
			{
				int index = list.FindIndex((KeyValuePair<TKey, TValue> kvp) => comparer.Equals(kvp.Key, key));
				dictionary[key] = value;
				list[index] = new KeyValuePair<TKey, TValue>(key, value);
			}
			else
			{
				Add(key, value);
			}
		}
	}

	public ICollection<TKey> Keys => new KeyCollection(this);

	public ICollection<TValue> Values => new ValueCollection(this);

	public int Count => dictionary.Count;

	public bool IsReadOnly => false;

	public KeyValuePair<TKey, TValue> this[int index]
	{
		get
		{
			return list[index];
		}
		set
		{
			list[index] = value;
		}
	}

	public OrderedDictionary()
		: this((IEqualityComparer<TKey>)EqualityComparer<TKey>.Default)
	{
	}

	public OrderedDictionary(IEqualityComparer<TKey> comparer)
	{
		list = new List<KeyValuePair<TKey, TValue>>();
		dictionary = new Dictionary<TKey, TValue>(comparer);
		this.comparer = comparer;
	}

	public void Add(TKey key, TValue value)
	{
		Add(new KeyValuePair<TKey, TValue>(key, value));
	}

	public void Add(KeyValuePair<TKey, TValue> item)
	{
		dictionary.Add(item.Key, item.Value);
		list.Add(item);
	}

	public void Clear()
	{
		dictionary.Clear();
		list.Clear();
	}

	public bool Contains(KeyValuePair<TKey, TValue> item)
	{
		return dictionary.Contains(item);
	}

	public bool ContainsKey(TKey key)
	{
		return dictionary.ContainsKey(key);
	}

	public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
	{
		list.CopyTo(array, arrayIndex);
	}

	public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
	{
		return list.GetEnumerator();
	}

	public void Insert(int index, TKey key, TValue value)
	{
		dictionary.Add(key, value);
		list.Insert(index, new KeyValuePair<TKey, TValue>(key, value));
	}

	public bool Remove(TKey key)
	{
		if (dictionary.ContainsKey(key))
		{
			int index = list.FindIndex((KeyValuePair<TKey, TValue> kvp) => comparer.Equals(kvp.Key, key));
			list.RemoveAt(index);
			if (!dictionary.Remove(key))
			{
				throw new InvalidOperationException();
			}
			return true;
		}
		return false;
	}

	public bool Remove(KeyValuePair<TKey, TValue> item)
	{
		return Remove(item.Key);
	}

	public void RemoveAt(int index)
	{
		TKey key = list[index].Key;
		dictionary.Remove(key);
		list.RemoveAt(index);
	}

	public bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value)
	{
		return dictionary.TryGetValue(key, out value);
	}

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

	[OnDeserialized]
	internal void OnDeserializedMethod(StreamingContext context)
	{
		dictionary = new Dictionary<TKey, TValue>();
		foreach (KeyValuePair<TKey, TValue> item in list)
		{
			dictionary[item.Key] = item.Value;
		}
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Helpers.StringBuilderPool ----
namespace YamlDotNet.Helpers
{
[DebuggerStepThrough]
internal static class StringBuilderPool
{
	internal readonly struct BuilderWrapper(StringBuilder builder, ConcurrentObjectPool<StringBuilder> pool) : IDisposable
	{
		public readonly StringBuilder Builder = builder;

		private readonly ConcurrentObjectPool<StringBuilder> _pool = pool;

		public override string ToString()
		{
			return Builder.ToString();
		}

		public void Dispose()
		{
			StringBuilder builder = Builder;
			if (builder.Capacity <= 1024)
			{
				builder.Length = 0;
				_pool.Free(builder);
			}
		}
	}

	private static readonly ConcurrentObjectPool<StringBuilder> Pool;

	static StringBuilderPool()
	{
		Pool = new ConcurrentObjectPool<StringBuilder>(() => new StringBuilder());
	}

	public static BuilderWrapper Rent()
	{
		return new BuilderWrapper(Pool.Allocate(), Pool);
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Helpers.ThrowHelper ----
namespace YamlDotNet.Helpers
{
internal static class ThrowHelper
{
	[MethodImpl(MethodImplOptions.NoInlining)]
	public static void ThrowArgumentOutOfRangeException(string paramName, string message)
	{
		throw new ArgumentOutOfRangeException(paramName, message);
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Helpers.Lazy ----
namespace YamlDotNet.Helpers
{
internal static class Lazy
{
	public static Lazy<T> FromValue<T>(T value)
	{
		Lazy<T> lazy = new Lazy<T>(() => value, isThreadSafe: false);
		_ = lazy.Value;
		return lazy;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Helpers.ReadOnlyCollectionExtensions ----
namespace YamlDotNet.Helpers
{
internal static class ReadOnlyCollectionExtensions
{
	public static IReadOnlyList<T> AsReadonlyList<T>(this List<T> list)
	{
		return list;
	}

	public static IReadOnlyDictionary<TKey, TValue> AsReadonlyDictionary<TKey, TValue>(this Dictionary<TKey, TValue> dictionary) where TKey : notnull
	{
		return dictionary;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.AnchorName ----
namespace YamlDotNet.Core
{
internal struct AnchorName : IEquatable<AnchorName>
{
	public static readonly AnchorName Empty = default(AnchorName);

	private static readonly Regex AnchorPattern = new Regex("^[^\\[\\]\\{\\},]+$", RegexOptions.Compiled);

	private readonly string? value;

	public string Value => value ?? throw new InvalidOperationException("Cannot read the Value of an empty anchor");

	public bool IsEmpty => value == null;

	public AnchorName(string value)
	{
		this.value = value ?? throw new ArgumentNullException("value");
		if (!AnchorPattern.IsMatch(value))
		{
			throw new ArgumentException("Anchor cannot be empty or contain disallowed characters: []{},\nThe value was '" + value + "'.", "value");
		}
	}

	public override string ToString()
	{
		return value ?? "[empty]";
	}

	public bool Equals(AnchorName other)
	{
		return object.Equals(value, other.value);
	}

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

	public override int GetHashCode()
	{
		return value?.GetHashCode() ?? 0;
	}

	public static bool operator ==(AnchorName left, AnchorName right)
	{
		return left.Equals(right);
	}

	public static bool operator !=(AnchorName left, AnchorName right)
	{
		return !(left == right);
	}

	public static implicit operator AnchorName(string? value)
	{
		if (value != null)
		{
			return new AnchorName(value);
		}
		return Empty;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.AnchorNotFoundException ----
namespace YamlDotNet.Core
{
internal class AnchorNotFoundException : YamlException
{
	public AnchorNotFoundException(string message)
		: base(message)
	{
	}

	public AnchorNotFoundException(in Mark start, in Mark end, string message)
		: base(in start, in end, message)
	{
	}

	public AnchorNotFoundException(string message, Exception inner)
		: base(message, inner)
	{
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.CharacterAnalyzer`1 ----
namespace YamlDotNet.Core
{
[DebuggerStepThrough]
internal sealed class CharacterAnalyzer<TBuffer> where TBuffer : class, ILookAheadBuffer
{
	public TBuffer Buffer { get; }

	public bool EndOfInput => Buffer.EndOfInput;

	public CharacterAnalyzer(TBuffer buffer)
	{
		Buffer = buffer ?? throw new ArgumentNullException("buffer");
	}

	public char Peek(int offset)
	{
		return Buffer.Peek(offset);
	}

	public void Skip(int length)
	{
		Buffer.Skip(length);
	}

	public bool IsAlphaNumericDashOrUnderscore(int offset = 0)
	{
		char c = Buffer.Peek(offset);
		if ((c < '0' || c > '9') && (c < 'A' || c > 'Z') && (c < 'a' || c > 'z') && c != '_')
		{
			return c == '-';
		}
		return true;
	}

	public bool IsAscii(int offset = 0)
	{
		return Buffer.Peek(offset) <= '\u007f';
	}

	public bool IsPrintable(int offset = 0)
	{
		char c = Buffer.Peek(offset);
		switch (c)
		{
		default:
			if (c != '\u0085' && (c < '\u00a0' || c > '\ud7ff'))
			{
				if (c >= '\ue000')
				{
					return c <= '\ufffd';
				}
				return false;
			}
			break;
		case '\t':
		case '\n':
		case '\r':
		case ' ':
		case '!':
		case '"':
		case '#':
		case '$':
		case '%':
		case '&':
		case '\'':
		case '(':
		case ')':
		case '*':
		case '+':
		case ',':
		case '-':
		case '.':
		case '/':
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
		case ':':
		case ';':
		case '<':
		case '=':
		case '>':
		case '?':
		case '@':
		case 'A':
		case 'B':
		case 'C':
		case 'D':
		case 'E':
		case 'F':
		case 'G':
		case 'H':
		case 'I':
		case 'J':
		case 'K':
		case 'L':
		case 'M':
		case 'N':
		case 'O':
		case 'P':
		case 'Q':
		case 'R':
		case 'S':
		case 'T':
		case 'U':
		case 'V':
		case 'W':
		case 'X':
		case 'Y':
		case 'Z':
		case '[':
		case '\\':
		case ']':
		case '^':
		case '_':
		case '`':
		case 'a':
		case 'b':
		case 'c':
		case 'd':
		case 'e':
		case 'f':
		case 'g':
		case 'h':
		case 'i':
		case 'j':
		case 'k':
		case 'l':
		case 'm':
		case 'n':
		case 'o':
		case 'p':
		case 'q':
		case 'r':
		case 's':
		case 't':
		case 'u':
		case 'v':
		case 'w':
		case 'x':
		case 'y':
		case 'z':
		case '{':
		case '|':
		case '}':
		case '~':
			break;
		}
		return true;
	}

	public bool IsDigit(int offset = 0)
	{
		char c = Buffer.Peek(offset);
		if (c >= '0')
		{
			return c <= '9';
		}
		return false;
	}

	public int AsDigit(int offset = 0)
	{
		return Buffer.Peek(offset) - 48;
	}

	public bool IsHex(int offset)
	{
		char c = Buffer.Peek(offset);
		if ((c < '0' || c > '9') && (c < 'A' || c > 'F'))
		{
			if (c >= 'a')
			{
				return c <= 'f';
			}
			return false;
		}
		return true;
	}

	public int AsHex(int offset)
	{
		char c = Buffer.Peek(offset);
		if (c <= '9')
		{
			return c - 48;
		}
		if (c <= 'F')
		{
			return c - 65 + 10;
		}
		return c - 97 + 10;
	}

	public bool IsSpace(int offset = 0)
	{
		return Check(' ', offset);
	}

	public bool IsZero(int offset = 0)
	{
		return Check('\0', offset);
	}

	public bool IsTab(int offset = 0)
	{
		return Check('\t', offset);
	}

	public bool IsWhite(int offset = 0)
	{
		if (!IsSpace(offset))
		{
			return IsTab(offset);
		}
		return true;
	}

	public bool IsBreak(int offset = 0)
	{
		return Check("\r\n\u0085\u2028\u2029", offset);
	}

	public bool IsCrLf(int offset = 0)
	{
		if (Check('\r', offset))
		{
			return Check('\n', offset + 1);
		}
		return false;
	}

	public bool IsBreakOrZero(int offset = 0)
	{
		if (!IsBreak(offset))
		{
			return IsZero(offset);
		}
		return true;
	}

	public bool IsWhiteBreakOrZero(int offset = 0)
	{
		if (!IsWhite(offset))
		{
			return IsBreakOrZero(offset);
		}
		return true;
	}

	public bool Check(char expected, int offset = 0)
	{
		return Buffer.Peek(offset) == expected;
	}

	public bool Check(string expectedCharacters, int offset = 0)
	{
		char value = Buffer.Peek(offset);
		return expectedCharacters.IndexOf(value) != -1;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Constants ----
namespace YamlDotNet.Core
{
internal static class Constants
{
	public static readonly TagDirective[] DefaultTagDirectives = new TagDirective[2]
	{
		new TagDirective("!", "!"),
		new TagDirective("!!", "tag:yaml.org,2002:")
	};

	public const int MajorVersion = 1;

	public const int MinorVersion = 3;
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Cursor ----
namespace YamlDotNet.Core
{
[DebuggerStepThrough]
internal sealed class Cursor
{
	public int Index { get; private set; }

	public int Line { get; private set; }

	public int LineOffset { get; private set; }

	public Cursor()
	{
		Line = 1;
	}

	public Cursor(Cursor cursor)
	{
		Index = cursor.Index;
		Line = cursor.Line;
		LineOffset = cursor.LineOffset;
	}

	public Mark Mark()
	{
		return new Mark(Index, Line, LineOffset + 1);
	}

	public void Skip()
	{
		Index++;
		LineOffset++;
	}

	public void SkipLineByOffset(int offset)
	{
		Index += offset;
		Line++;
		LineOffset = 0;
	}

	public void ForceSkipLineAfterNonBreak()
	{
		if (LineOffset != 0)
		{
			Line++;
			LineOffset = 0;
		}
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Emitter ----
namespace YamlDotNet.Core
{
internal class Emitter : IEmitter
{
	private class AnchorData
	{
		public AnchorName Anchor;

		public bool IsAlias;
	}

	private class TagData
	{
		public string? Handle;

		public string? Suffix;
	}

	private class ScalarData
	{
		public string Value = string.Empty;

		public bool IsMultiline;

		public bool IsFlowPlainAllowed;

		public bool IsBlockPlainAllowed;

		public bool IsSingleQuotedAllowed;

		public bool IsBlockAllowed;

		public bool HasSingleQuotes;

		public ScalarStyle Style;
	}

	private static readonly Regex UriReplacer = new Regex("[^0-9A-Za-z_\\-;?@=$~\\\\\\)\\]/:&+,\\.\\*\\(\\[!]", RegexOptions.Compiled | RegexOptions.Singleline);

	private static readonly string[] newLineSeparators = new string[3] { "\r\n", "\r", "\n" };

	private readonly TextWriter output;

	private readonly bool outputUsesUnicodeEncoding;

	private readonly int maxSimpleKeyLength;

	private readonly bool isCanonical;

	private readonly bool skipAnchorName;

	private readonly int bestIndent;

	private readonly int bestWidth;

	private EmitterState state;

	private readonly Stack<EmitterState> states = new Stack<EmitterState>();

	private readonly Queue<ParsingEvent> events = new Queue<ParsingEvent>();

	private readonly Stack<int> indents = new Stack<int>();

	private readonly TagDirectiveCollection tagDirectives = new TagDirectiveCollection();

	private int indent;

	private int flowLevel;

	private bool isMappingContext;

	private bool isSimpleKeyContext;

	private int column;

	private bool isWhitespace;

	private bool isIndentation;

	private readonly bool forceIndentLess;

	private readonly string newLine;

	private bool isDocumentEndWritten;

	private readonly AnchorData anchorData = new AnchorData();

	private readonly TagData tagData = new TagData();

	private readonly ScalarData scalarData = new ScalarData();

	public Emitter(TextWriter output)
		: this(output, EmitterSettings.Default)
	{
	}

	public Emitter(TextWriter output, int bestIndent)
		: this(output, bestIndent, int.MaxValue)
	{
	}

	public Emitter(TextWriter output, int bestIndent, int bestWidth)
		: this(output, bestIndent, bestWidth, isCanonical: false)
	{
	}

	public Emitter(TextWriter output, int bestIndent, int bestWidth, bool isCanonical)
		: this(output, new EmitterSettings(bestIndent, bestWidth, isCanonical, 1024))
	{
	}

	public Emitter(TextWriter output, EmitterSettings settings)
	{
		bestIndent = settings.BestIndent;
		bestWidth = settings.BestWidth;
		isCanonical = settings.IsCanonical;
		maxSimpleKeyLength = settings.MaxSimpleKeyLength;
		skipAnchorName = settings.SkipAnchorName;
		forceIndentLess = !settings.IndentSequences;
		newLine = settings.NewLine;
		this.output = output;
		outputUsesUnicodeEncoding = IsUnicode(output.Encoding);
	}

	public void Emit(ParsingEvent @event)
	{
		events.Enqueue(@event);
		while (!NeedMoreEvents())
		{
			ParsingEvent evt = events.Peek();
			try
			{
				AnalyzeEvent(evt);
				StateMachine(evt);
			}
			finally
			{
				events.Dequeue();
			}
		}
	}

	private bool NeedMoreEvents()
	{
		if (events.Count == 0)
		{
			return true;
		}
		int num;
		switch (events.Peek().Type)
		{
		case EventType.DocumentStart:
			num = 1;
			break;
		case EventType.SequenceStart:
			num = 2;
			break;
		case EventType.MappingStart:
			num = 3;
			break;
		default:
			return false;
		}
		if (events.Count > num)
		{
			return false;
		}
		int num2 = 0;
		foreach (ParsingEvent @event in events)
		{
			switch (@event.Type)
			{
			case EventType.DocumentStart:
			case EventType.SequenceStart:
			case EventType.MappingStart:
				num2++;
				break;
			case EventType.DocumentEnd:
			case EventType.SequenceEnd:
			case EventType.MappingEnd:
				num2--;
				break;
			}
			if (num2 == 0)
			{
				return false;
			}
		}
		return true;
	}

	private void AnalyzeEvent(ParsingEvent evt)
	{
		anchorData.Anchor = AnchorName.Empty;
		tagData.Handle = null;
		tagData.Suffix = null;
		if (evt is YamlDotNet.Core.Events.AnchorAlias anchorAlias)
		{
			AnalyzeAnchor(anchorAlias.Value, isAlias: true);
		}
		else if (evt is NodeEvent nodeEvent)
		{
			if (evt is YamlDotNet.Core.Events.Scalar scalar)
			{
				AnalyzeScalar(scalar);
			}
			AnalyzeAnchor(nodeEvent.Anchor, isAlias: false);
			if (!nodeEvent.Tag.IsEmpty && (isCanonical || nodeEvent.IsCanonical))
			{
				AnalyzeTag(nodeEvent.Tag);
			}
		}
	}

	private void AnalyzeAnchor(AnchorName anchor, bool isAlias)
	{
		anchorData.Anchor = anchor;
		anchorData.IsAlias = isAlias;
	}

	private void AnalyzeScalar(YamlDotNet.Core.Events.Scalar scalar)
	{
		string value = scalar.Value;
		scalarData.Value = value;
		if (value.Length == 0)
		{
			if (scalar.Tag == "tag:yaml.org,2002:null")
			{
				scalarData.IsMultiline = false;
				scalarData.IsFlowPlainAllowed = false;
				scalarData.IsBlockPlainAllowed = true;
				scalarData.IsSingleQuotedAllowed = false;
				scalarData.IsBlockAllowed = false;
			}
			else
			{
				scalarData.IsMultiline = false;
				scalarData.IsFlowPlainAllowed = false;
				scalarData.IsBlockPlainAllowed = false;
				scalarData.IsSingleQuotedAllowed = true;
				scalarData.IsBlockAllowed = false;
			}
			return;
		}
		bool flag = false;
		bool flag2 = false;
		if (value.StartsWith("---", StringComparison.Ordinal) || value.StartsWith("...", StringComparison.Ordinal))
		{
			flag = true;
			flag2 = true;
		}
		CharacterAnalyzer<StringLookAheadBuffer> characterAnalyzer = new CharacterAnalyzer<StringLookAheadBuffer>(new StringLookAheadBuffer(value));
		bool flag3 = true;
		bool flag4 = characterAnalyzer.IsWhiteBreakOrZero(1);
		bool flag5 = false;
		bool flag6 = false;
		bool flag7 = false;
		bool flag8 = false;
		bool flag9 = false;
		bool flag10 = false;
		bool flag11 = false;
		bool flag12 = false;
		bool flag13 = false;
		bool flag14 = false;
		bool flag15 = false;
		bool flag16 = !ValueIsRepresentableInOutputEncoding(value);
		bool flag17 = false;
		bool flag18 = false;
		bool flag19 = true;
		while (!characterAnalyzer.EndOfInput)
		{
			if (flag19)
			{
				if (characterAnalyzer.Check("#,[]{}&*!|>\\\"%@`'"))
				{
					flag = true;
					flag2 = true;
					flag9 = characterAnalyzer.Check('\'');
					flag17 |= characterAnalyzer.Check('\'');
				}
				if (characterAnalyzer.Check("?:"))
				{
					flag = true;
					if (flag4)
					{
						flag2 = true;
					}
				}
				if (characterAnalyzer.Check('-') && flag4)
				{
					flag = true;
					flag2 = true;
				}
			}
			else
			{
				if (characterAnalyzer.Check(",?[]{}"))
				{
					flag = true;
				}
				if (characterAnalyzer.Check(':'))
				{
					flag = true;
					if (flag4)
					{
						flag2 = true;
					}
				}
				if (characterAnalyzer.Check('#') && flag3)
				{
					flag = true;
					flag2 = true;
				}
				flag17 |= characterAnalyzer.Check('\'');
			}
			if (!flag16 && !characterAnalyzer.IsPrintable())
			{
				flag16 = true;
			}
			if (characterAnalyzer.IsBreak())
			{
				flag15 = true;
			}
			if (characterAnalyzer.IsSpace())
			{
				if (flag19)
				{
					flag5 = true;
				}
				if (characterAnalyzer.Buffer.Position >= characterAnalyzer.Buffer.Length - 1)
				{
					flag7 = true;
				}
				if (flag13)
				{
					flag10 = true;
					flag14 = true;
				}
				flag12 = true;
				flag13 = false;
			}
			else if (characterAnalyzer.IsBreak())
			{
				if (flag19)
				{
					flag6 = true;
				}
				if (characterAnalyzer.Buffer.Position >= characterAnalyzer.Buffer.Length - 1)
				{
					flag8 = true;
				}
				if (flag12)
				{
					flag11 = true;
				}
				if (flag14)
				{
					flag18 = true;
				}
				flag12 = false;
				flag13 = true;
			}
			else
			{
				flag12 = false;
				flag13 = false;
				flag14 = false;
			}
			flag3 = characterAnalyzer.IsWhiteBreakOrZero();
			characterAnalyzer.Skip(1);
			if (!characterAnalyzer.EndOfInput)
			{
				flag4 = characterAnalyzer.IsWhiteBreakOrZero(1);
			}
			flag19 = false;
		}
		scalarData.IsFlowPlainAllowed = true;
		scalarData.IsBlockPlainAllowed = true;
		scalarData.IsSingleQuotedAllowed = true;
		scalarData.IsBlockAllowed = true;
		if (flag5 || flag6 || flag7 || flag8 || flag9)
		{
			scalarData.IsFlowPlainAllowed = false;
			scalarData.IsBlockPlainAllowed = false;
		}
		if (flag7)
		{
			scalarData.IsBlockAllowed = false;
		}
		if (flag10)
		{
			scalarData.IsFlowPlainAllowed = false;
			scalarData.IsBlockPlainAllowed = false;
			scalarData.IsSingleQuotedAllowed = false;
		}
		if (flag11 || flag16)
		{
			scalarData.IsFlowPlainAllowed = false;
			scalarData.IsBlockPlainAllowed = false;
			scalarData.IsSingleQuotedAllowed = false;
		}
		if (flag18)
		{
			scalarData.IsBlockAllowed = false;
		}
		scalarData.IsMultiline = flag15;
		if (flag15)
		{
			scalarData.IsFlowPlainAllowed = false;
			scalarData.IsBlockPlainAllowed = false;
		}
		if (flag)
		{
			scalarData.IsFlowPlainAllowed = false;
		}
		if (flag2)
		{
			scalarData.IsBlockPlainAllowed = false;
		}
		scalarData.HasSingleQuotes = flag17;
	}

	private bool ValueIsRepresentableInOutputEncoding(string value)
	{
		if (outputUsesUnicodeEncoding)
		{
			return true;
		}
		try
		{
			byte[] bytes = output.Encoding.GetBytes(value);
			return output.Encoding.GetString(bytes, 0, bytes.Length).Equals(value);
		}
		catch (EncoderFallbackException)
		{
			return false;
		}
		catch (ArgumentOutOfRangeException)
		{
			return false;
		}
	}

	private bool IsUnicode(Encoding encoding)
	{
		if (!(encoding is UTF8Encoding) && !(encoding is UnicodeEncoding))
		{
			return encoding is UTF7Encoding;
		}
		return true;
	}

	private void AnalyzeTag(TagName tag)
	{
		tagData.Handle = tag.Value;
		foreach (TagDirective tagDirective in tagDirectives)
		{
			if (tag.Value.StartsWith(tagDirective.Prefix, StringComparison.Ordinal))
			{
				tagData.Handle = tagDirective.Handle;
				tagData.Suffix = tag.Value.Substring(tagDirective.Prefix.Length);
				break;
			}
		}
	}

	private void StateMachine(ParsingEvent evt)
	{
		if (evt is YamlDotNet.Core.Events.Comment comment)
		{
			EmitComment(comment);
			return;
		}
		switch (state)
		{
		case EmitterState.StreamStart:
			EmitStreamStart(evt);
			break;
		case EmitterState.FirstDocumentStart:
			EmitDocumentStart(evt, isFirst: true);
			break;
		case EmitterState.DocumentStart:
			EmitDocumentStart(evt, isFirst: false);
			break;
		case EmitterState.DocumentContent:
			EmitDocumentContent(evt);
			break;
		case EmitterState.DocumentEnd:
			EmitDocumentEnd(evt);
			break;
		case EmitterState.FlowSequenceFirstItem:
			EmitFlowSequenceItem(evt, isFirst: true);
			break;
		case EmitterState.FlowSequenceItem:
			EmitFlowSequenceItem(evt, isFirst: false);
			break;
		case EmitterState.FlowMappingFirstKey:
			EmitFlowMappingKey(evt, isFirst: true);
			break;
		case EmitterState.FlowMappingKey:
			EmitFlowMappingKey(evt, isFirst: false);
			break;
		case EmitterState.FlowMappingSimpleValue:
			EmitFlowMappingValue(evt, isSimple: true);
			break;
		case EmitterState.FlowMappingValue:
			EmitFlowMappingValue(evt, isSimple: false);
			break;
		case EmitterState.BlockSequenceFirstItem:
			EmitBlockSequenceItem(evt, isFirst: true);
			break;
		case EmitterState.BlockSequenceItem:
			EmitBlockSequenceItem(evt, isFirst: false);
			break;
		case EmitterState.BlockMappingFirstKey:
			EmitBlockMappingKey(evt, isFirst: true);
			break;
		case EmitterState.BlockMappingKey:
			EmitBlockMappingKey(evt, isFirst: false);
			break;
		case EmitterState.BlockMappingSimpleValue:
			EmitBlockMappingValue(evt, isSimple: true);
			break;
		case EmitterState.BlockMappingValue:
			EmitBlockMappingValue(evt, isSimple: false);
			break;
		case EmitterState.StreamEnd:
			throw new YamlException("Expected nothing after STREAM-END");
		default:
			throw new InvalidOperationException();
		}
	}

	private void EmitComment(YamlDotNet.Core.Events.Comment comment)
	{
		if (flowLevel > 0 || state == EmitterState.FlowMappingFirstKey || state == EmitterState.FlowSequenceFirstItem)
		{
			return;
		}
		string[] array = comment.Value.Split(newLineSeparators, StringSplitOptions.None);
		if (comment.IsInline)
		{
			Write(" # ");
			Write(string.Join(" ", array));
		}
		else
		{
			bool flag = state == EmitterState.BlockMappingFirstKey;
			if (flag)
			{
				IncreaseIndent(isFlow: false, isIndentless: false);
			}
			string[] array2 = array;
			foreach (string value in array2)
			{
				WriteIndent();
				Write("# ");
				Write(value);
				WriteBreak();
			}
			if (flag)
			{
				indent = indents.Pop();
			}
		}
		isIndentation = true;
	}

	private void EmitStreamStart(ParsingEvent evt)
	{
		if (!(evt is YamlDotNet.Core.Events.StreamStart))
		{
			throw new ArgumentException("Expected STREAM-START.", "evt");
		}
		indent = -1;
		column = 0;
		isWhitespace = true;
		isIndentation = true;
		state = EmitterState.FirstDocumentStart;
	}

	private void EmitDocumentStart(ParsingEvent evt, bool isFirst)
	{
		if (evt is YamlDotNet.Core.Events.DocumentStart documentStart)
		{
			bool flag = documentStart.IsImplicit && isFirst && !isCanonical;
			TagDirectiveCollection tagDirectiveCollection = NonDefaultTagsAmong(documentStart.Tags);
			if (!isFirst && !isDocumentEndWritten && (documentStart.Version != null || tagDirectiveCollection.Count > 0))
			{
				isDocumentEndWritten = false;
				WriteIndicator("...", needWhitespace: true, whitespace: false, indentation: false);
				WriteIndent();
			}
			if (documentStart.Version != null)
			{
				AnalyzeVersionDirective(documentStart.Version);
				Version version = documentStart.Version.Version;
				flag = false;
				WriteIndicator("%YAML", needWhitespace: true, whitespace: false, indentation: false);
				WriteIndicator(string.Format(CultureInfo.InvariantCulture, "{0}.{1}", version.Major, version.Minor), needWhitespace: true, whitespace: false, indentation: false);
				WriteIndent();
			}
			foreach (TagDirective item in tagDirectiveCollection)
			{
				AppendTagDirectiveTo(item, allowDuplicates: false, tagDirectives);
			}
			TagDirective[] defaultTagDirectives = Constants.DefaultTagDirectives;
			for (int i = 0; i < defaultTagDirectives.Length; i++)
			{
				AppendTagDirectiveTo(defaultTagDirectives[i], allowDuplicates: true, tagDirectives);
			}
			if (tagDirectiveCollection.Count > 0)
			{
				flag = false;
				defaultTagDirectives = Constants.DefaultTagDirectives;
				for (int i = 0; i < defaultTagDirectives.Length; i++)
				{
					AppendTagDirectiveTo(defaultTagDirectives[i], allowDuplicates: true, tagDirectiveCollection);
				}
				foreach (TagDirective item2 in tagDirectiveCollection)
				{
					WriteIndicator("%TAG", needWhitespace: true, whitespace: false, indentation: false);
					WriteTagHandle(item2.Handle);
					WriteTagContent(item2.Prefix, needsWhitespace: true);
					WriteIndent();
				}
			}
			if (CheckEmptyDocument())
			{
				flag = false;
			}
			if (!flag)
			{
				WriteIndent();
				WriteIndicator("---", needWhitespace: true, whitespace: false, indentation: false);
				if (isCanonical)
				{
					WriteIndent();
				}
			}
			state = EmitterState.DocumentContent;
		}
		else
		{
			if (!(evt is YamlDotNet.Core.Events.StreamEnd))
			{
				throw new YamlException("Expected DOCUMENT-START or STREAM-END");
			}
			state = EmitterState.StreamEnd;
		}
	}

	private TagDirectiveCollection NonDefaultTagsAmong(IEnumerable<TagDirective>? tagCollection)
	{
		TagDirectiveCollection tagDirectiveCollection = new TagDirectiveCollection();
		if (tagCollection == null)
		{
			return tagDirectiveCollection;
		}
		foreach (TagDirective item2 in tagCollection)
		{
			AppendTagDirectiveTo(item2, allowDuplicates: false, tagDirectiveCollection);
		}
		TagDirective[] defaultTagDirectives = Constants.DefaultTagDirectives;
		foreach (TagDirective item in defaultTagDirectives)
		{
			tagDirectiveCollection.Remove(item);
		}
		return tagDirectiveCollection;
	}

	private void AnalyzeVersionDirective(VersionDirective versionDirective)
	{
		if (versionDirective.Version.Major != 1 || versionDirective.Version.Minor > 3)
		{
			throw new YamlException("Incompatible %YAML directive");
		}
	}

	private static void AppendTagDirectiveTo(TagDirective value, bool allowDuplicates, TagDirectiveCollection tagDirectives)
	{
		if (tagDirectives.Contains(value))
		{
			if (!allowDuplicates)
			{
				throw new YamlException("Duplicate %TAG directive.");
			}
		}
		else
		{
			tagDirectives.Add(value);
		}
	}

	private void EmitDocumentContent(ParsingEvent evt)
	{
		states.Push(EmitterState.DocumentEnd);
		EmitNode(evt, isMapping: false, isSimpleKey: false);
	}

	private void EmitNode(ParsingEvent evt, bool isMapping, bool isSimpleKey)
	{
		isMappingContext = isMapping;
		isSimpleKeyContext = isSimpleKey;
		switch (evt.Type)
		{
		case EventType.Alias:
			EmitAlias();
			break;
		case EventType.Scalar:
			EmitScalar(evt);
			break;
		case EventType.SequenceStart:
			EmitSequenceStart(evt);
			break;
		case EventType.MappingStart:
			EmitMappingStart(evt);
			break;
		default:
			throw new YamlException($"Expected SCALAR, SEQUENCE-START, MAPPING-START, or ALIAS, got {evt.Type}");
		}
	}

	private void EmitAlias()
	{
		ProcessAnchor();
		state = states.Pop();
	}

	private void EmitScalar(ParsingEvent evt)
	{
		SelectScalarStyle(evt);
		ProcessAnchor();
		ProcessTag();
		IncreaseIndent(isFlow: true, isIndentless: false);
		ProcessScalar();
		indent = indents.Pop();
		state = states.Pop();
	}

	private void SelectScalarStyle(ParsingEvent evt)
	{
		YamlDotNet.Core.Events.Scalar scalar = (YamlDotNet.Core.Events.Scalar)evt;
		ScalarStyle scalarStyle = scalar.Style;
		bool flag = tagData.Handle == null && tagData.Suffix == null;
		if (flag && !scalar.IsPlainImplicit && !scalar.IsQuotedImplicit)
		{
			throw new YamlException("Neither tag nor isImplicit flags are specified.");
		}
		if (scalarStyle == ScalarStyle.Any)
		{
			scalarStyle = ((!scalarData.IsMultiline) ? ScalarStyle.Plain : ScalarStyle.Folded);
		}
		if (isCanonical)
		{
			scalarStyle = ScalarStyle.DoubleQuoted;
		}
		if (isSimpleKeyContext && scalarData.IsMultiline)
		{
			scalarStyle = ScalarStyle.DoubleQuoted;
		}
		if (scalarStyle == ScalarStyle.Plain)
		{
			if ((flowLevel != 0 && !scalarData.IsFlowPlainAllowed) || (flowLevel == 0 && !scalarData.IsBlockPlainAllowed))
			{
				scalarStyle = ((scalarData.IsSingleQuotedAllowed && !scalarData.HasSingleQuotes) ? ScalarStyle.SingleQuoted : ScalarStyle.DoubleQuoted);
			}
			if (string.IsNullOrEmpty(scalarData.Value) && (flowLevel != 0 || isSimpleKeyContext))
			{
				scalarStyle = ScalarStyle.SingleQuoted;
			}
			if (flag && !scalar.IsPlainImplicit)
			{
				scalarStyle = ScalarStyle.SingleQuoted;
			}
		}
		if (scalarStyle == ScalarStyle.SingleQuoted && !scalarData.IsSingleQuotedAllowed)
		{
			scalarStyle = ScalarStyle.DoubleQuoted;
		}
		if ((scalarStyle == ScalarStyle.Literal || scalarStyle == ScalarStyle.Folded) && (!scalarData.IsBlockAllowed || flowLevel != 0 || isSimpleKeyContext))
		{
			scalarStyle = ScalarStyle.DoubleQuoted;
		}
		scalarData.Style = scalarStyle;
	}

	private void ProcessScalar()
	{
		switch (scalarData.Style)
		{
		case ScalarStyle.Plain:
			WritePlainScalar(scalarData.Value, !isSimpleKeyContext);
			break;
		case ScalarStyle.SingleQuoted:
			WriteSingleQuotedScalar(scalarData.Value, !isSimpleKeyContext);
			break;
		case ScalarStyle.DoubleQuoted:
			WriteDoubleQuotedScalar(scalarData.Value, !isSimpleKeyContext);
			break;
		case ScalarStyle.Literal:
			WriteLiteralScalar(scalarData.Value);
			break;
		case ScalarStyle.Folded:
			WriteFoldedScalar(scalarData.Value);
			break;
		default:
			throw new InvalidOperationException();
		}
	}

	private void WritePlainScalar(string value, bool allowBreaks)
	{
		if (!isWhitespace)
		{
			Write(' ');
		}
		bool flag = false;
		bool flag2 = false;
		for (int i = 0; i < value.Length; i++)
		{
			char c = value[i];
			if (IsSpace(c))
			{
				if (allowBreaks && !flag && column > bestWidth && i + 1 < value.Length && value[i + 1] != ' ')
				{
					WriteIndent();
				}
				else
				{
					Write(c);
				}
				flag = true;
				continue;
			}
			if (IsBreak(c, out var breakChar))
			{
				if (!flag2 && c == '\n')
				{
					WriteBreak();
				}
				WriteBreak(breakChar);
				isIndentation = true;
				flag2 = true;
				continue;
			}
			if (flag2)
			{
				WriteIndent();
			}
			Write(c);
			isIndentation = false;
			flag = false;
			flag2 = false;
		}
		isWhitespace = false;
		isIndentation = false;
	}

	private void WriteSingleQuotedScalar(string value, bool allowBreaks)
	{
		WriteIndicator("'", needWhitespace: true, whitespace: false, indentation: false);
		bool flag = false;
		bool flag2 = false;
		for (int i = 0; i < value.Length; i++)
		{
			char c = value[i];
			if (c == ' ')
			{
				if (allowBreaks && !flag && column > bestWidth && i != 0 && i + 1 < value.Length && value[i + 1] != ' ')
				{
					WriteIndent();
				}
				else
				{
					Write(c);
				}
				flag = true;
				continue;
			}
			if (IsBreak(c, out var breakChar))
			{
				if (!flag2 && c == '\n')
				{
					WriteBreak();
				}
				WriteBreak(breakChar);
				isIndentation = true;
				flag2 = true;
				continue;
			}
			if (flag2)
			{
				WriteIndent();
			}
			if (c == '\'')
			{
				Write(c);
			}
			Write(c);
			isIndentation = false;
			flag = false;
			flag2 = false;
		}
		WriteIndicator("'", needWhitespace: false, whitespace: false, indentation: false);
		isWhitespace = false;
		isIndentation = false;
	}

	private void WriteDoubleQuotedScalar(string value, bool allowBreaks)
	{
		WriteIndicator("\"", needWhitespace: true, whitespace: false, indentation: false);
		bool flag = false;
		for (int i = 0; i < value.Length; i++)
		{
			char c = value[i];
			if (IsPrintable(c) && !IsBreak(c, out var _))
			{
				switch (c)
				{
				case '"':
				case '\\':
					break;
				case ' ':
					if (allowBreaks && !flag && column > bestWidth && i > 0 && i + 1 < value.Length)
					{
						WriteIndent();
						if (value[i + 1] == ' ')
						{
							Write('\\');
						}
					}
					else
					{
						Write(c);
					}
					flag = true;
					continue;
				default:
					Write(c);
					flag = false;
					continue;
				}
			}
			Write('\\');
			switch (c)
			{
			case '\0':
				Write('0');
				break;
			case '\a':
				Write('a');
				break;
			case '\b':
				Write('b');
				break;
			case '\t':
				Write('t');
				break;
			case '\n':
				Write('n');
				break;
			case '\v':
				Write('v');
				break;
			case '\f':
				Write('f');
				break;
			case '\r':
				Write('r');
				break;
			case '\u001b':
				Write('e');
				break;
			case '"':
				Write('"');
				break;
			case '\\':
				Write('\\');
				break;
			case '\u0085':
				Write('N');
				break;
			case '\u00a0':
				Write('_');
				break;
			case '\u2028':
				Write('L');
				break;
			case '\u2029':
				Write('P');
				break;
			default:
			{
				ushort num = c;
				if (num <= 255)
				{
					Write('x');
					Write(num.ToString("X02", CultureInfo.InvariantCulture));
				}
				else if (IsHighSurrogate(c))
				{
					if (i + 1 >= value.Length || !IsLowSurrogate(value[i + 1]))
					{
						throw new SyntaxErrorException("While writing a quoted scalar, found an orphaned high surrogate.");
					}
					Write('U');
					Write(char.ConvertToUtf32(c, value[i + 1]).ToString("X08", CultureInfo.InvariantCulture));
					i++;
				}
				else
				{
					Write('u');
					Write(num.ToString("X04", CultureInfo.InvariantCulture));
				}
				break;
			}
			}
			flag = false;
		}
		WriteIndicator("\"", needWhitespace: false, whitespace: false, indentation: false);
		isWhitespace = false;
		isIndentation = false;
	}

	private void WriteLiteralScalar(string value)
	{
		bool flag = true;
		WriteIndicator("|", needWhitespace: true, whitespace: false, indentation: false);
		WriteBlockScalarHints(value);
		WriteBreak();
		isIndentation = true;
		isWhitespace = true;
		for (int i = 0; i < value.Length; i++)
		{
			char c = value[i];
			if (c == '\r' && i + 1 < value.Length && value[i + 1] == '\n')
			{
				continue;
			}
			if (IsBreak(c, out var breakChar))
			{
				WriteBreak(breakChar);
				isIndentation = true;
				flag = true;
				continue;
			}
			if (flag)
			{
				WriteIndent();
			}
			Write(c);
			isIndentation = false;
			flag = false;
		}
	}

	private void WriteFoldedScalar(string value)
	{
		bool flag = true;
		bool flag2 = true;
		WriteIndicator(">", needWhitespace: true, whitespace: false, indentation: false);
		WriteBlockScalarHints(value);
		WriteBreak();
		isIndentation = true;
		isWhitespace = true;
		for (int i = 0; i < value.Length; i++)
		{
			char c = value[i];
			if (IsBreak(c, out var breakChar))
			{
				if (c == '\r' && i + 1 < value.Length && value[i + 1] == '\n')
				{
					continue;
				}
				if (!flag && !flag2 && breakChar == '\n')
				{
					int j;
					char breakChar2;
					for (j = 0; i + j < value.Length && IsBreak(value[i + j], out breakChar2); j++)
					{
					}
					if (i + j < value.Length && !IsBlank(value[i + j]) && !IsBreak(value[i + j], out breakChar2))
					{
						WriteBreak();
					}
				}
				WriteBreak(breakChar);
				isIndentation = true;
				flag = true;
			}
			else
			{
				if (flag)
				{
					WriteIndent();
					flag2 = IsBlank(c);
				}
				if (!flag && c == ' ' && i + 1 < value.Length && value[i + 1] != ' ' && column > bestWidth)
				{
					WriteIndent();
				}
				else
				{
					Write(c);
				}
				isIndentation = false;
				flag = false;
			}
		}
	}

	private static bool IsSpace(char character)
	{
		return character == ' ';
	}

	private static bool IsBreak(char character, out char breakChar)
	{
		switch (character)
		{
		case '\n':
		case '\r':
		case '\u0085':
			breakChar = '\n';
			return true;
		case '\u2028':
		case '\u2029':
			breakChar = character;
			return true;
		default:
			breakChar = '\0';
			return false;
		}
	}

	private static bool IsBlank(char character)
	{
		if (character != ' ')
		{
			return character == '\t';
		}
		return true;
	}

	private static bool IsPrintable(char character)
	{
		switch (character)
		{
		default:
			if (character != '\u0085' && (character < '\u00a0' || character > '\ud7ff'))
			{
				if (character >= '\ue000')
				{
					return character <= '\ufffd';
				}
				return false;
			}
			break;
		case '\t':
		case '\n':
		case '\r':
		case ' ':
		case '!':
		case '"':
		case '#':
		case '$':
		case '%':
		case '&':
		case '\'':
		case '(':
		case ')':
		case '*':
		case '+':
		case ',':
		case '-':
		case '.':
		case '/':
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
		case ':':
		case ';':
		case '<':
		case '=':
		case '>':
		case '?':
		case '@':
		case 'A':
		case 'B':
		case 'C':
		case 'D':
		case 'E':
		case 'F':
		case 'G':
		case 'H':
		case 'I':
		case 'J':
		case 'K':
		case 'L':
		case 'M':
		case 'N':
		case 'O':
		case 'P':
		case 'Q':
		case 'R':
		case 'S':
		case 'T':
		case 'U':
		case 'V':
		case 'W':
		case 'X':
		case 'Y':
		case 'Z':
		case '[':
		case '\\':
		case ']':
		case '^':
		case '_':
		case '`':
		case 'a':
		case 'b':
		case 'c':
		case 'd':
		case 'e':
		case 'f':
		case 'g':
		case 'h':
		case 'i':
		case 'j':
		case 'k':
		case 'l':
		case 'm':
		case 'n':
		case 'o':
		case 'p':
		case 'q':
		case 'r':
		case 's':
		case 't':
		case 'u':
		case 'v':
		case 'w':
		case 'x':
		case 'y':
		case 'z':
		case '{':
		case '|':
		case '}':
		case '~':
			break;
		}
		return true;
	}

	private static bool IsHighSurrogate(char c)
	{
		if ('\ud800' <= c)
		{
			return c <= '\udbff';
		}
		return false;
	}

	private static bool IsLowSurrogate(char c)
	{
		if ('\udc00' <= c)
		{
			return c <= '\udfff';
		}
		return false;
	}

	private void EmitSequenceStart(ParsingEvent evt)
	{
		ProcessAnchor();
		ProcessTag();
		SequenceStart sequenceStart = (SequenceStart)evt;
		if (flowLevel != 0 || isCanonical || sequenceStart.Style == SequenceStyle.Flow || CheckEmptySequence())
		{
			state = EmitterState.FlowSequenceFirstItem;
		}
		else
		{
			state = EmitterState.BlockSequenceFirstItem;
		}
	}

	private void EmitMappingStart(ParsingEvent evt)
	{
		ProcessAnchor();
		ProcessTag();
		MappingStart mappingStart = (MappingStart)evt;
		if (flowLevel != 0 || isCanonical || mappingStart.Style == MappingStyle.Flow || CheckEmptyMapping())
		{
			state = EmitterState.FlowMappingFirstKey;
		}
		else
		{
			state = EmitterState.BlockMappingFirstKey;
		}
	}

	private void ProcessAnchor()
	{
		if (!anchorData.Anchor.IsEmpty && !skipAnchorName)
		{
			WriteIndicator(anchorData.IsAlias ? "*" : "&", needWhitespace: true, whitespace: false, indentation: false);
			WriteAnchor(anchorData.Anchor);
		}
	}

	private void ProcessTag()
	{
		if (tagData.Handle == null && tagData.Suffix == null)
		{
			return;
		}
		if (tagData.Handle != null)
		{
			WriteTagHandle(tagData.Handle);
			if (tagData.Suffix != null)
			{
				WriteTagContent(tagData.Suffix, needsWhitespace: false);
			}
		}
		else
		{
			WriteIndicator("!<", needWhitespace: true, whitespace: false, indentation: false);
			WriteTagContent(tagData.Suffix, needsWhitespace: false);
			WriteIndicator(">", needWhitespace: false, whitespace: false, indentation: false);
		}
	}

	private void EmitDocumentEnd(ParsingEvent evt)
	{
		if (evt is YamlDotNet.Core.Events.DocumentEnd documentEnd)
		{
			WriteIndent();
			if (!documentEnd.IsImplicit)
			{
				WriteIndicator("...", needWhitespace: true, whitespace: false, indentation: false);
				WriteIndent();
				isDocumentEndWritten = true;
			}
			state = EmitterState.DocumentStart;
			tagDirectives.Clear();
			return;
		}
		throw new YamlException("Expected DOCUMENT-END.");
	}

	private void EmitFlowSequenceItem(ParsingEvent evt, bool isFirst)
	{
		if (isFirst)
		{
			WriteIndicator("[", needWhitespace: true, whitespace: true, indentation: false);
			IncreaseIndent(isFlow: true, isIndentless: false);
			flowLevel++;
		}
		if (evt is SequenceEnd)
		{
			flowLevel--;
			indent = indents.Pop();
			if (isCanonical && !isFirst)
			{
				WriteIndicator(",", needWhitespace: false, whitespace: false, indentation: false);
				WriteIndent();
			}
			WriteIndicator("]", needWhitespace: false, whitespace: false, indentation: false);
			state = states.Pop();
		}
		else
		{
			if (!isFirst)
			{
				WriteIndicator(",", needWhitespace: false, whitespace: false, indentation: false);
			}
			if (isCanonical || column > bestWidth)
			{
				WriteIndent();
			}
			states.Push(EmitterState.FlowSequenceItem);
			EmitNode(evt, isMapping: false, isSimpleKey: false);
		}
	}

	private void EmitFlowMappingKey(ParsingEvent evt, bool isFirst)
	{
		if (isFirst)
		{
			WriteIndicator("{", needWhitespace: true, whitespace: true, indentation: false);
			IncreaseIndent(isFlow: true, isIndentless: false);
			flowLevel++;
		}
		if (evt is MappingEnd)
		{
			flowLevel--;
			indent = indents.Pop();
			if (isCanonical && !isFirst)
			{
				WriteIndicator(",", needWhitespace: false, whitespace: false, indentation: false);
				WriteIndent();
			}
			WriteIndicator("}", needWhitespace: false, whitespace: false, indentation: false);
			state = states.Pop();
			return;
		}
		if (!isFirst)
		{
			WriteIndicator(",", needWhitespace: false, whitespace: false, indentation: false);
		}
		if (isCanonical || column > bestWidth)
		{
			WriteIndent();
		}
		if (!isCanonical && CheckSimpleKey())
		{
			states.Push(EmitterState.FlowMappingSimpleValue);
			EmitNode(evt, isMapping: true, isSimpleKey: true);
		}
		else
		{
			WriteIndicator("?", needWhitespace: true, whitespace: false, indentation: false);
			states.Push(EmitterState.FlowMappingValue);
			EmitNode(evt, isMapping: true, isSimpleKey: false);
		}
	}

	private void EmitFlowMappingValue(ParsingEvent evt, bool isSimple)
	{
		if (isSimple)
		{
			WriteIndicator(":", needWhitespace: false, whitespace: false, indentation: false);
		}
		else
		{
			if (isCanonical || column > bestWidth)
			{
				WriteIndent();
			}
			WriteIndicator(":", needWhitespace: true, whitespace: false, indentation: false);
		}
		states.Push(EmitterState.FlowMappingKey);
		EmitNode(evt, isMapping: true, isSimpleKey: false);
	}

	private void EmitBlockSequenceItem(ParsingEvent evt, bool isFirst)
	{
		if (isFirst)
		{
			IncreaseIndent(isFlow: false, isMappingContext && !isIndentation);
		}
		if (evt is SequenceEnd)
		{
			indent = indents.Pop();
			state = states.Pop();
			return;
		}
		WriteIndent();
		WriteIndicator("-", needWhitespace: true, whitespace: false, indentation: true);
		states.Push(EmitterState.BlockSequenceItem);
		EmitNode(evt, isMapping: false, isSimpleKey: false);
	}

	private void EmitBlockMappingKey(ParsingEvent evt, bool isFirst)
	{
		if (isFirst)
		{
			IncreaseIndent(isFlow: false, isIndentless: false);
		}
		if (evt is MappingEnd)
		{
			indent = indents.Pop();
			state = states.Pop();
			return;
		}
		WriteIndent();
		if (CheckSimpleKey())
		{
			states.Push(EmitterState.BlockMappingSimpleValue);
			EmitNode(evt, isMapping: true, isSimpleKey: true);
			WriteIndicator(":", needWhitespace: false, whitespace: false, indentation: false);
		}
		else
		{
			WriteIndicator("?", needWhitespace: true, whitespace: false, indentation: true);
			states.Push(EmitterState.BlockMappingValue);
			EmitNode(evt, isMapping: true, isSimpleKey: false);
		}
	}

	private void EmitBlockMappingValue(ParsingEvent evt, bool isSimple)
	{
		if (!isSimple)
		{
			WriteIndent();
			WriteIndicator(":", needWhitespace: true, whitespace: false, indentation: true);
		}
		states.Push(EmitterState.BlockMappingKey);
		EmitNode(evt, isMapping: true, isSimpleKey: false);
	}

	private void IncreaseIndent(bool isFlow, bool isIndentless)
	{
		indents.Push(indent);
		if (indent < 0)
		{
			indent = (isFlow ? bestIndent : 0);
		}
		else if (!isIndentless || !forceIndentLess)
		{
			indent += bestIndent;
		}
	}

	private bool CheckEmptyDocument()
	{
		int num = 0;
		foreach (ParsingEvent @event in events)
		{
			num++;
			if (num == 2)
			{
				if (@event is YamlDotNet.Core.Events.Scalar scalar)
				{
					return string.IsNullOrEmpty(scalar.Value);
				}
				break;
			}
		}
		return false;
	}

	private bool CheckSimpleKey()
	{
		if (events.Count < 1)
		{
			return false;
		}
		int num;
		switch (events.Peek().Type)
		{
		case EventType.Alias:
			num = AnchorNameLength(anchorData.Anchor);
			break;
		case EventType.Scalar:
			if (scalarData.IsMultiline)
			{
				return false;
			}
			num = AnchorNameLength(anchorData.Anchor) + SafeStringLength(tagData.Handle) + SafeStringLength(tagData.Suffix) + SafeStringLength(scalarData.Value);
			break;
		case EventType.SequenceStart:
			if (!CheckEmptySequence())
			{
				return false;
			}
			num = AnchorNameLength(anchorData.Anchor) + SafeStringLength(tagData.Handle) + SafeStringLength(tagData.Suffix);
			break;
		case EventType.MappingStart:
			if (!CheckEmptySequence())
			{
				return false;
			}
			num = AnchorNameLength(anchorData.Anchor) + SafeStringLength(tagData.Handle) + SafeStringLength(tagData.Suffix);
			break;
		default:
			return false;
		}
		return num <= maxSimpleKeyLength;
	}

	private int AnchorNameLength(AnchorName value)
	{
		if (!value.IsEmpty)
		{
			return value.Value.Length;
		}
		return 0;
	}

	private int SafeStringLength(string? value)
	{
		return value?.Length ?? 0;
	}

	private bool CheckEmptySequence()
	{
		return CheckEmptyStructure<SequenceStart, SequenceEnd>();
	}

	private bool CheckEmptyMapping()
	{
		return CheckEmptyStructure<MappingStart, MappingEnd>();
	}

	private bool CheckEmptyStructure<TStart, TEnd>() where TStart : NodeEvent where TEnd : ParsingEvent
	{
		if (events.Count < 2)
		{
			return false;
		}
		using Queue<ParsingEvent>.Enumerator enumerator = events.GetEnumerator();
		return enumerator.MoveNext() && enumerator.Current is TStart && enumerator.MoveNext() && enumerator.Current is TEnd;
	}

	private void WriteBlockScalarHints(string value)
	{
		CharacterAnalyzer<StringLookAheadBuffer> characterAnalyzer = new CharacterAnalyzer<StringLookAheadBuffer>(new StringLookAheadBuffer(value));
		if (characterAnalyzer.IsSpace() || characterAnalyzer.IsBreak())
		{
			int num = bestIndent;
			string indicator = num.ToString(CultureInfo.InvariantCulture);
			WriteIndicator(indicator, needWhitespace: false, whitespace: false, indentation: false);
		}
		string text = null;
		if (value.Length == 0 || !characterAnalyzer.IsBreak(value.Length - 1))
		{
			text = "-";
		}
		else if (value.Length >= 2 && characterAnalyzer.IsBreak(value.Length - 2))
		{
			text = "+";
		}
		if (text != null)
		{
			WriteIndicator(text, needWhitespace: false, whitespace: false, indentation: false);
		}
	}

	private void WriteIndicator(string indicator, bool needWhitespace, bool whitespace, bool indentation)
	{
		if (needWhitespace && !isWhitespace)
		{
			Write(' ');
		}
		Write(indicator);
		isWhitespace = whitespace;
		isIndentation &= indentation;
	}

	private void WriteIndent()
	{
		int num = Math.Max(indent, 0);
		if (!isIndentation || column > num || (column == num && !isWhitespace))
		{
			WriteBreak();
		}
		while (column < num)
		{
			Write(' ');
		}
		isWhitespace = true;
		isIndentation = true;
	}

	private void WriteAnchor(AnchorName value)
	{
		Write(value.Value);
		isWhitespace = false;
		isIndentation = false;
	}

	private void WriteTagHandle(string value)
	{
		if (!isWhitespace)
		{
			Write(' ');
		}
		Write(value);
		isWhitespace = false;
		isIndentation = false;
	}

	private void WriteTagContent(string value, bool needsWhitespace)
	{
		if (needsWhitespace && !isWhitespace)
		{
			Write(' ');
		}
		Write(UrlEncode(value));
		isWhitespace = false;
		isIndentation = false;
	}

	private static string UrlEncode(string text)
	{
		return UriReplacer.Replace(text, delegate(Match match)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				byte[] bytes = Encoding.UTF8.GetBytes(match.Value);
				foreach (byte b in bytes)
				{
					builder.AppendFormat("%{0:X02}", b);
				}
				return builder.ToString();
			}
			finally
			{
				((IDisposable)builderWrapper/*cast due to constrained. prefix*//*cast due to constrained. prefix*/).Dispose();
			}
		});
	}

	private void Write(char value)
	{
		output.Write(value);
		column++;
	}

	private void Write(string value)
	{
		output.Write(value);
		column += value.Length;
	}

	private void WriteBreak(char breakCharacter = '\n')
	{
		if (breakCharacter == '\n')
		{
			output.Write(newLine);
		}
		else
		{
			output.Write(breakCharacter);
		}
		column = 0;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.EmitterSettings ----
namespace YamlDotNet.Core
{
internal sealed class EmitterSettings
{
	public static readonly EmitterSettings Default = new EmitterSettings();

	public int BestIndent { get; } = 2;

	public int BestWidth { get; } = int.MaxValue;

	public string NewLine { get; } = Environment.NewLine;

	public bool IsCanonical { get; }

	public bool SkipAnchorName { get; private set; }

	public int MaxSimpleKeyLength { get; } = 1024;

	public bool IndentSequences { get; }

	public EmitterSettings()
	{
	}

	public EmitterSettings(int bestIndent, int bestWidth, bool isCanonical, int maxSimpleKeyLength, bool skipAnchorName = false, bool indentSequences = false, string? newLine = null)
	{
		if (bestIndent < 2 || bestIndent > 9)
		{
			throw new ArgumentOutOfRangeException("bestIndent", "BestIndent must be between 2 and 9, inclusive");
		}
		if (bestWidth <= bestIndent * 2)
		{
			throw new ArgumentOutOfRangeException("bestWidth", "BestWidth must be greater than BestIndent x 2.");
		}
		if (maxSimpleKeyLength < 0)
		{
			throw new ArgumentOutOfRangeException("maxSimpleKeyLength", "MaxSimpleKeyLength must be >= 0");
		}
		BestIndent = bestIndent;
		BestWidth = bestWidth;
		IsCanonical = isCanonical;
		MaxSimpleKeyLength = maxSimpleKeyLength;
		SkipAnchorName = skipAnchorName;
		IndentSequences = indentSequences;
		NewLine = newLine ?? Environment.NewLine;
	}

	public EmitterSettings WithBestIndent(int bestIndent)
	{
		return new EmitterSettings(bestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, IndentSequences, NewLine);
	}

	public EmitterSettings WithBestWidth(int bestWidth)
	{
		return new EmitterSettings(BestIndent, bestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, IndentSequences, NewLine);
	}

	public EmitterSettings WithMaxSimpleKeyLength(int maxSimpleKeyLength)
	{
		return new EmitterSettings(BestIndent, BestWidth, IsCanonical, maxSimpleKeyLength, SkipAnchorName, IndentSequences, NewLine);
	}

	public EmitterSettings WithNewLine(string newLine)
	{
		return new EmitterSettings(BestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, IndentSequences, newLine);
	}

	public EmitterSettings Canonical()
	{
		return new EmitterSettings(BestIndent, BestWidth, isCanonical: true, MaxSimpleKeyLength, SkipAnchorName);
	}

	public EmitterSettings WithoutAnchorName()
	{
		return new EmitterSettings(BestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, skipAnchorName: true, IndentSequences, NewLine);
	}

	public EmitterSettings WithIndentedSequences()
	{
		return new EmitterSettings(BestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, indentSequences: true, NewLine);
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.EmitterState ----
namespace YamlDotNet.Core
{
internal enum EmitterState
{
	StreamStart,
	StreamEnd,
	FirstDocumentStart,
	DocumentStart,
	DocumentContent,
	DocumentEnd,
	FlowSequenceFirstItem,
	FlowSequenceItem,
	FlowMappingFirstKey,
	FlowMappingKey,
	FlowMappingSimpleValue,
	FlowMappingValue,
	BlockSequenceFirstItem,
	BlockSequenceItem,
	BlockMappingFirstKey,
	BlockMappingKey,
	BlockMappingSimpleValue,
	BlockMappingValue
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.ForwardAnchorNotSupportedException ----
namespace YamlDotNet.Core
{
internal sealed class ForwardAnchorNotSupportedException : YamlException
{
	public ForwardAnchorNotSupportedException(string message)
		: base(message)
	{
	}

	public ForwardAnchorNotSupportedException(in Mark start, in Mark end, string message)
		: base(in start, in end, message)
	{
	}

	public ForwardAnchorNotSupportedException(string message, Exception inner)
		: base(message, inner)
	{
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.HashCode ----
namespace YamlDotNet.Core
{
internal static class HashCode
{
	public static int CombineHashCodes(int h1, int h2)
	{
		return ((h1 << 5) + h1) ^ h2;
	}

	public static int CombineHashCodes(int h1, object? o2)
	{
		return CombineHashCodes(h1, GetHashCode(o2));
	}

	private static int GetHashCode(object? obj)
	{
		return obj?.GetHashCode() ?? 0;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.IEmitter ----
namespace YamlDotNet.Core
{
internal interface IEmitter
{
	void Emit(ParsingEvent @event);
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.ILookAheadBuffer ----
namespace YamlDotNet.Core
{
internal interface ILookAheadBuffer
{
	bool EndOfInput { get; }

	char Peek(int offset);

	void Skip(int length);
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.InsertionQueue`1 ----
namespace YamlDotNet.Core
{
internal sealed class InsertionQueue<T> : IEnumerable<T>, IEnumerable
{
	private const int DefaultInitialCapacity = 128;

	private T[] items;

	private int readPtr;

	private int writePtr;

	private int mask;

	private int count;

	public int Count => count;

	public int Capacity => items.Length;

	public InsertionQueue(int initialCapacity = 128)
	{
		if (initialCapacity <= 0)
		{
			throw new ArgumentOutOfRangeException("initialCapacity", "The initial capacity must be a positive number.");
		}
		if (!initialCapacity.IsPowerOfTwo())
		{
			throw new ArgumentException("The initial capacity must be a power of 2.", "initialCapacity");
		}
		items = new T[initialCapacity];
		readPtr = initialCapacity / 2;
		writePtr = initialCapacity / 2;
		mask = initialCapacity - 1;
	}

	public void Enqueue(T item)
	{
		ResizeIfNeeded();
		items[writePtr] = item;
		writePtr = (writePtr - 1) & mask;
		count++;
	}

	public T Dequeue()
	{
		if (count == 0)
		{
			throw new InvalidOperationException("The queue is empty");
		}
		T result = items[readPtr];
		readPtr = (readPtr - 1) & mask;
		count--;
		return result;
	}

	public void Insert(int index, T item)
	{
		if (index > count)
		{
			throw new InvalidOperationException("Cannot insert outside of the bounds of the queue");
		}
		ResizeIfNeeded();
		CalculateInsertionParameters(mask, count, index, ref readPtr, ref writePtr, out var insertPtr, out var copyIndex, out var copyOffset, out var copyLength);
		if (copyLength != 0)
		{
			Array.Copy(items, copyIndex, items, copyIndex + copyOffset, copyLength);
		}
		items[insertPtr] = item;
		count++;
	}

	private void ResizeIfNeeded()
	{
		int num = items.Length;
		if (count == num)
		{
			T[] destinationArray = new T[num * 2];
			int num2 = readPtr + 1;
			if (num2 > 0)
			{
				Array.Copy(items, 0, destinationArray, 0, num2);
			}
			writePtr += num;
			int num3 = num - num2;
			if (num3 > 0)
			{
				Array.Copy(items, readPtr + 1, destinationArray, writePtr + 1, num3);
			}
			items = destinationArray;
			mask = mask * 2 + 1;
		}
	}

	internal static void CalculateInsertionParameters(int mask, int count, int index, ref int readPtr, ref int writePtr, out int insertPtr, out int copyIndex, out int copyOffset, out int copyLength)
	{
		int num = (readPtr + 1) & mask;
		if (index == 0)
		{
			insertPtr = (readPtr = num);
			copyIndex = 0;
			copyOffset = 0;
			copyLength = 0;
			return;
		}
		insertPtr = (readPtr - index) & mask;
		if (index == count)
		{
			writePtr = (writePtr - 1) & mask;
			copyIndex = 0;
			copyOffset = 0;
			copyLength = 0;
			return;
		}
		int num2 = ((num >= insertPtr) ? (readPtr - insertPtr) : int.MaxValue);
		int num3 = ((writePtr <= insertPtr) ? (insertPtr - writePtr) : int.MaxValue);
		if (num2 <= num3)
		{
			insertPtr++;
			readPtr++;
			copyIndex = insertPtr;
			copyOffset = 1;
			copyLength = num2;
		}
		else
		{
			copyIndex = writePtr + 1;
			copyOffset = -1;
			copyLength = num3;
			writePtr = (writePtr - 1) & mask;
		}
	}

	public IEnumerator<T> GetEnumerator()
	{
		int ptr = readPtr;
		for (int i = 0; i < Count; i++)
		{
			yield return items[ptr];
			ptr = (ptr - 1) & mask;
		}
	}

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

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.IParser ----
namespace YamlDotNet.Core
{
internal interface IParser
{
	ParsingEvent? Current { get; }

	bool MoveNext();
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.IScanner ----
namespace YamlDotNet.Core
{
internal interface IScanner
{
	Mark CurrentPosition { get; }

	Token? Current { get; }

	bool MoveNext();

	bool MoveNextWithoutConsuming();

	void ConsumeCurrent();
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.LookAheadBuffer ----
namespace YamlDotNet.Core
{
[DebuggerStepThrough]
internal sealed class LookAheadBuffer : ILookAheadBuffer
{
	private readonly TextReader input;

	private readonly char[] buffer;

	private readonly int blockSize;

	private readonly int mask;

	private int firstIndex;

	private int writeOffset;

	private int count;

	private bool endOfInput;

	public bool EndOfInput
	{
		get
		{
			if (endOfInput)
			{
				return count == 0;
			}
			return false;
		}
	}

	public LookAheadBuffer(TextReader input, int capacity)
	{
		if (capacity < 1)
		{
			throw new ArgumentOutOfRangeException("capacity", "The capacity must be positive.");
		}
		if (!capacity.IsPowerOfTwo())
		{
			throw new ArgumentException("The capacity must be a power of 2.", "capacity");
		}
		this.input = input ?? throw new ArgumentNullException("input");
		blockSize = capacity;
		buffer = new char[capacity * 2];
		mask = capacity * 2 - 1;
	}

	private int GetIndexForOffset(int offset)
	{
		return (firstIndex + offset) & mask;
	}

	public char Peek(int offset)
	{
		if (offset >= count)
		{
			FillBuffer();
		}
		if (offset < count)
		{
			return buffer[(firstIndex + offset) & mask];
		}
		return '\0';
	}

	public void Cache(int length)
	{
		if (length >= count)
		{
			FillBuffer();
		}
	}

	private void FillBuffer()
	{
		if (endOfInput)
		{
			return;
		}
		int num = blockSize;
		do
		{
			int num2 = input.Read(buffer, writeOffset, num);
			if (num2 == 0)
			{
				endOfInput = true;
				return;
			}
			num -= num2;
			writeOffset += num2;
			count += num2;
		}
		while (num > 0);
		if (writeOffset == buffer.Length)
		{
			writeOffset = 0;
		}
	}

	public void Skip(int length)
	{
		if (length < 1 || length > blockSize)
		{
			throw new ArgumentOutOfRangeException("length", "The length must be between 1 and the number of characters in the buffer. Use the Peek() and / or Cache() methods to fill the buffer.");
		}
		firstIndex = GetIndexForOffset(length);
		count -= length;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Mark ----
namespace YamlDotNet.Core
{
internal readonly struct Mark : IEquatable<Mark>, IComparable<Mark>, IComparable
{
	public static readonly Mark Empty = new Mark(0, 1, 1);

	public int Index { get; }

	public int Line { get; }

	public int Column { get; }

	public Mark(int index, int line, int column)
	{
		if (index < 0)
		{
			ThrowHelper.ThrowArgumentOutOfRangeException("index", "Index must be greater than or equal to zero.");
		}
		if (line < 1)
		{
			ThrowHelper.ThrowArgumentOutOfRangeException("line", "Line must be greater than or equal to 1.");
		}
		if (column < 1)
		{
			ThrowHelper.ThrowArgumentOutOfRangeException("column", "Column must be greater than or equal to 1.");
		}
		Index = index;
		Line = line;
		Column = column;
	}

	public override string ToString()
	{
		return $"Line: {Line}, Col: {Column}, Idx: {Index}";
	}

	public override bool Equals(object? obj)
	{
		return Equals((Mark)(obj ?? ((object)Empty)));
	}

	public bool Equals(Mark other)
	{
		if (Index == other.Index && Line == other.Line)
		{
			return Column == other.Column;
		}
		return false;
	}

	public override int GetHashCode()
	{
		return HashCode.CombineHashCodes(Index.GetHashCode(), HashCode.CombineHashCodes(Line.GetHashCode(), Column.GetHashCode()));
	}

	public int CompareTo(object? obj)
	{
		return CompareTo((Mark)(obj ?? ((object)Empty)));
	}

	public int CompareTo(Mark other)
	{
		int num = Line.CompareTo(other.Line);
		if (num == 0)
		{
			num = Column.CompareTo(other.Column);
		}
		return num;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.MaximumRecursionLevelReachedException ----
namespace YamlDotNet.Core
{
internal sealed class MaximumRecursionLevelReachedException : YamlException
{
	public MaximumRecursionLevelReachedException(string message)
		: base(message)
	{
	}

	public MaximumRecursionLevelReachedException(in Mark start, in Mark end, string message)
		: base(in start, in end, message)
	{
	}

	public MaximumRecursionLevelReachedException(string message, Exception inner)
		: base(message, inner)
	{
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.MergingParser ----
namespace YamlDotNet.Core
{
internal sealed class MergingParser : IParser
{
	private sealed class ParsingEventCollection : IEnumerable<LinkedListNode<ParsingEvent>>, IEnumerable
	{
		private readonly LinkedList<ParsingEvent> events;

		private readonly HashSet<LinkedListNode<ParsingEvent>> deleted;

		private readonly Dictionary<AnchorName, LinkedListNode<ParsingEvent>> references;

		public ParsingEventCollection()
		{
			events = new LinkedList<ParsingEvent>();
			deleted = new HashSet<LinkedListNode<ParsingEvent>>();
			references = new Dictionary<AnchorName, LinkedListNode<ParsingEvent>>();
		}

		public void AddAfter(LinkedListNode<ParsingEvent> node, IEnumerable<ParsingEvent> items)
		{
			foreach (ParsingEvent item in items)
			{
				node = events.AddAfter(node, item);
			}
		}

		public void Add(ParsingEvent item)
		{
			LinkedListNode<ParsingEvent> node = events.AddLast(item);
			AddReference(item, node);
		}

		public void MarkDeleted(LinkedListNode<ParsingEvent> node)
		{
			deleted.Add(node);
		}

		public bool IsDeleted(LinkedListNode<ParsingEvent> node)
		{
			return deleted.Contains(node);
		}

		public void CleanMarked()
		{
			foreach (LinkedListNode<ParsingEvent> item in deleted)
			{
				events.Remove(item);
			}
		}

		public IEnumerable<LinkedListNode<ParsingEvent>> FromAnchor(AnchorName anchor)
		{
			LinkedListNode<ParsingEvent> next = references[anchor].Next;
			return Enumerate(next);
		}

		public IEnumerator<LinkedListNode<ParsingEvent>> GetEnumerator()
		{
			return Enumerate(events.First).GetEnumerator();
		}

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

		private IEnumerable<LinkedListNode<ParsingEvent>> Enumerate(LinkedListNode<ParsingEvent>? node)
		{
			while (node != null)
			{
				yield return node;
				node = node.Next;
			}
		}

		private void AddReference(ParsingEvent item, LinkedListNode<ParsingEvent> node)
		{
			if (item is MappingStart { Anchor: { IsEmpty: false } anchor })
			{
				references[anchor] = node;
			}
		}
	}

	private sealed class ParsingEventCloner : IParsingEventVisitor
	{
		private ParsingEvent? clonedEvent;

		public ParsingEvent Clone(ParsingEvent e)
		{
			e.Accept(this);
			if (clonedEvent == null)
			{
				throw new InvalidOperationException($"Could not clone event of type '{e.Type}'");
			}
			return clonedEvent;
		}

		void IParsingEventVisitor.Visit(AnchorAlias e)
		{
			clonedEvent = new AnchorAlias(e.Value, e.Start, e.End);
		}

		void IParsingEventVisitor.Visit(StreamStart e)
		{
			throw new NotSupportedException();
		}

		void IParsingEventVisitor.Visit(StreamEnd e)
		{
			throw new NotSupportedException();
		}

		void IParsingEventVisitor.Visit(DocumentStart e)
		{
			throw new NotSupportedException();
		}

		void IParsingEventVisitor.Visit(DocumentEnd e)
		{
			throw new NotSupportedException();
		}

		void IParsingEventVisitor.Visit(Scalar e)
		{
			clonedEvent = new Scalar(AnchorName.Empty, e.Tag, e.Value, e.Style, e.IsPlainImplicit, e.IsQuotedImplicit, e.Start, e.End);
		}

		void IParsingEventVisitor.Visit(SequenceStart e)
		{
			clonedEvent = new SequenceStart(AnchorName.Empty, e.Tag, e.IsImplicit, e.Style, e.Start, e.End);
		}

		void IParsingEventVisitor.Visit(SequenceEnd e)
		{
			clonedEvent = new SequenceEnd(e.Start, e.End);
		}

		void IParsingEventVisitor.Visit(MappingStart e)
		{
			clonedEvent = new MappingStart(AnchorName.Empty, e.Tag, e.IsImplicit, e.Style, e.Start, e.End);
		}

		void IParsingEventVisitor.Visit(MappingEnd e)
		{
			clonedEvent = new MappingEnd(e.Start, e.End);
		}

		void IParsingEventVisitor.Visit(Comment e)
		{
			throw new NotSupportedException();
		}
	}

	private readonly ParsingEventCollection events;

	private readonly IParser innerParser;

	private IEnumerator<LinkedListNode<ParsingEvent>> iterator;

	private bool merged;

	public ParsingEvent? Current => iterator.Current?.Value;

	public MergingParser(IParser innerParser)
	{
		events = new ParsingEventCollection();
		merged = false;
		iterator = events.GetEnumerator();
		this.innerParser = innerParser;
	}

	public bool MoveNext()
	{
		if (!merged)
		{
			Merge();
			events.CleanMarked();
			iterator = events.GetEnumerator();
			merged = true;
		}
		return iterator.MoveNext();
	}

	private void Merge()
	{
		while (innerParser.MoveNext())
		{
			events.Add(innerParser.Current);
		}
		foreach (LinkedListNode<ParsingEvent> @event in events)
		{
			if (IsMergeToken(@event))
			{
				events.MarkDeleted(@event);
				if (!HandleMerge(@event.Next))
				{
					throw new SemanticErrorException(@event.Value.Start, @event.Value.End, "Unrecognized merge key pattern");
				}
			}
		}
	}

	private bool HandleMerge(LinkedListNode<ParsingEvent>? node)
	{
		if (node == null)
		{
			return false;
		}
		if (node.Value is AnchorAlias anchorAlias)
		{
			return HandleAnchorAlias(node, node, anchorAlias);
		}
		if (node.Value is SequenceStart)
		{
			return HandleSequence(node);
		}
		return false;
	}

	private bool HandleMergeSequence(LinkedListNode<ParsingEvent> sequenceStart, LinkedListNode<ParsingEvent>? node)
	{
		if (node == null)
		{
			return false;
		}
		if (node.Value is AnchorAlias anchorAlias)
		{
			return HandleAnchorAlias(sequenceStart, node, anchorAlias);
		}
		if (node.Value is SequenceStart)
		{
			return HandleSequence(node);
		}
		return false;
	}

	private bool IsMergeToken(LinkedListNode<ParsingEvent> node)
	{
		if (node.Value is Scalar scalar)
		{
			return scalar.Value == "<<";
		}
		return false;
	}

	private bool HandleAnchorAlias(LinkedListNode<ParsingEvent> node, LinkedListNode<ParsingEvent> anchorNode, AnchorAlias anchorAlias)
	{
		IEnumerable<ParsingEvent> mappingEvents = GetMappingEvents(anchorAlias.Value);
		events.AddAfter(node, mappingEvents);
		events.MarkDeleted(anchorNode);
		return true;
	}

	private bool HandleSequence(LinkedListNode<ParsingEvent> node)
	{
		events.MarkDeleted(node);
		LinkedListNode<ParsingEvent> linkedListNode = node;
		while (linkedListNode != null)
		{
			if (linkedListNode.Value is SequenceEnd)
			{
				events.MarkDeleted(linkedListNode);
				return true;
			}
			LinkedListNode<ParsingEvent> next = linkedListNode.Next;
			HandleMergeSequence(node, next);
			linkedListNode = next;
		}
		return true;
	}

	private IEnumerable<ParsingEvent> GetMappingEvents(AnchorName anchor)
	{
		ParsingEventCloner cloner = new ParsingEventCloner();
		int nesting = 0;
		return from e in (from e in events.FromAnchor(anchor)
				where !events.IsDeleted(e)
				select e.Value).TakeWhile((ParsingEvent e) => (nesting += e.NestingIncrease) >= 0)
			select cloner.Clone(e);
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Parser ----
namespace YamlDotNet.Core
{
internal class Parser : IParser
{
	private class EventQueue
	{
		private readonly Queue<ParsingEvent> highPriorityEvents = new Queue<ParsingEvent>();

		private readonly Queue<ParsingEvent> normalPriorityEvents = new Queue<ParsingEvent>();

		public int Count => highPriorityEvents.Count + normalPriorityEvents.Count;

		public void Enqueue(ParsingEvent @event)
		{
			EventType type = @event.Type;
			if (type == EventType.StreamStart || type == EventType.DocumentStart)
			{
				highPriorityEvents.Enqueue(@event);
			}
			else
			{
				normalPriorityEvents.Enqueue(@event);
			}
		}

		public ParsingEvent Dequeue()
		{
			if (highPriorityEvents.Count <= 0)
			{
				return normalPriorityEvents.Dequeue();
			}
			return highPriorityEvents.Dequeue();
		}
	}

	private readonly Stack<ParserState> states = new Stack<ParserState>();

	private readonly TagDirectiveCollection tagDirectives = new TagDirectiveCollection();

	private ParserState state;

	private readonly IScanner scanner;

	private Token? currentToken;

	private VersionDirective? version;

	private readonly EventQueue pendingEvents = new EventQueue();

	public ParsingEvent? Current { get; private set; }

	private Token? GetCurrentToken()
	{
		if (currentToken == null)
		{
			while (scanner.MoveNextWithoutConsuming())
			{
				currentToken = scanner.Current;
				if (!(currentToken is YamlDotNet.Core.Tokens.Comment comment))
				{
					break;
				}
				pendingEvents.Enqueue(new YamlDotNet.Core.Events.Comment(comment.Value, comment.IsInline, comment.Start, comment.End));
				scanner.ConsumeCurrent();
			}
		}
		return currentToken;
	}

	public Parser(TextReader input)
		: this(new Scanner(input))
	{
	}

	public Parser(IScanner scanner)
	{
		this.scanner = scanner;
	}

	public bool MoveNext()
	{
		if (state == ParserState.StreamEnd)
		{
			Current = null;
			return false;
		}
		if (pendingEvents.Count == 0)
		{
			pendingEvents.Enqueue(StateMachine());
		}
		Current = pendingEvents.Dequeue();
		return true;
	}

	private ParsingEvent StateMachine()
	{
		return state switch
		{
			ParserState.StreamStart => ParseStreamStart(), 
			ParserState.ImplicitDocumentStart => ParseDocumentStart(isImplicit: true), 
			ParserState.DocumentStart => ParseDocumentStart(isImplicit: false), 
			ParserState.DocumentContent => ParseDocumentContent(), 
			ParserState.DocumentEnd => ParseDocumentEnd(), 
			ParserState.BlockNode => ParseNode(isBlock: true, isIndentlessSequence: false), 
			ParserState.BlockNodeOrIndentlessSequence => ParseNode(isBlock: true, isIndentlessSequence: true), 
			ParserState.FlowNode => ParseNode(isBlock: false, isIndentlessSequence: false), 
			ParserState.BlockSequenceFirstEntry => ParseBlockSequenceEntry(isFirst: true), 
			ParserState.BlockSequenceEntry => ParseBlockSequenceEntry(isFirst: false), 
			ParserState.IndentlessSequenceEntry => ParseIndentlessSequenceEntry(), 
			ParserState.BlockMappingFirstKey => ParseBlockMappingKey(isFirst: true), 
			ParserState.BlockMappingKey => ParseBlockMappingKey(isFirst: false), 
			ParserState.BlockMappingValue => ParseBlockMappingValue(), 
			ParserState.FlowSequenceFirstEntry => ParseFlowSequenceEntry(isFirst: true), 
			ParserState.FlowSequenceEntry => ParseFlowSequenceEntry(isFirst: false), 
			ParserState.FlowSequenceEntryMappingKey => ParseFlowSequenceEntryMappingKey(), 
			ParserState.FlowSequenceEntryMappingValue => ParseFlowSequenceEntryMappingValue(), 
			ParserState.FlowSequenceEntryMappingEnd => ParseFlowSequenceEntryMappingEnd(), 
			ParserState.FlowMappingFirstKey => ParseFlowMappingKey(isFirst: true), 
			ParserState.FlowMappingKey => ParseFlowMappingKey(isFirst: false), 
			ParserState.FlowMappingValue => ParseFlowMappingValue(isEmpty: false), 
			ParserState.FlowMappingEmptyValue => ParseFlowMappingValue(isEmpty: true), 
			_ => throw new InvalidOperationException(), 
		};
	}

	private void Skip()
	{
		if (currentToken != null)
		{
			currentToken = null;
			scanner.ConsumeCurrent();
		}
	}

	private ParsingEvent ParseStreamStart()
	{
		Token token = GetCurrentToken();
		if (!(token is YamlDotNet.Core.Tokens.StreamStart streamStart))
		{
			throw new SemanticErrorException(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty, "Did not find expected <stream-start>.");
		}
		Skip();
		state = ParserState.ImplicitDocumentStart;
		return new YamlDotNet.Core.Events.StreamStart(streamStart.Start, streamStart.End);
	}

	private ParsingEvent ParseDocumentStart(bool isImplicit)
	{
		if (currentToken is VersionDirective)
		{
			throw new SyntaxErrorException("While parsing a document start node, could not find document end marker before version directive.");
		}
		Token token = GetCurrentToken();
		if (!isImplicit)
		{
			while (token is YamlDotNet.Core.Tokens.DocumentEnd)
			{
				Skip();
				token = GetCurrentToken();
			}
		}
		if (token == null)
		{
			throw new SyntaxErrorException("Reached the end of the stream while parsing a document start.");
		}
		if (token is YamlDotNet.Core.Tokens.Scalar && (state == ParserState.ImplicitDocumentStart || state == ParserState.DocumentStart))
		{
			isImplicit = true;
		}
		if ((isImplicit && !(token is VersionDirective) && !(token is TagDirective) && !(token is YamlDotNet.Core.Tokens.DocumentStart) && !(token is YamlDotNet.Core.Tokens.StreamEnd) && !(token is YamlDotNet.Core.Tokens.DocumentEnd)) || token is BlockMappingStart)
		{
			TagDirectiveCollection tags = new TagDirectiveCollection();
			ProcessDirectives(tags);
			states.Push(ParserState.DocumentEnd);
			state = ParserState.BlockNode;
			return new YamlDotNet.Core.Events.DocumentStart(null, tags, isImplicit: true, token.Start, token.End);
		}
		if (!(token is YamlDotNet.Core.Tokens.StreamEnd) && !(token is YamlDotNet.Core.Tokens.DocumentEnd))
		{
			Mark start = token.Start;
			TagDirectiveCollection tags2 = new TagDirectiveCollection();
			VersionDirective? versionDirective = ProcessDirectives(tags2);
			token = GetCurrentToken() ?? throw new SemanticErrorException("Reached the end of the stream while parsing a document start");
			if (!(token is YamlDotNet.Core.Tokens.DocumentStart))
			{
				throw new SemanticErrorException(token.Start, token.End, "Did not find expected <document start>.");
			}
			states.Push(ParserState.DocumentEnd);
			state = ParserState.DocumentContent;
			Mark end = token.End;
			Skip();
			return new YamlDotNet.Core.Events.DocumentStart(versionDirective, tags2, isImplicit: false, start, end);
		}
		if (token is YamlDotNet.Core.Tokens.DocumentEnd)
		{
			Skip();
		}
		state = ParserState.StreamEnd;
		token = GetCurrentToken() ?? throw new SemanticErrorException("Reached the end of the stream while parsing a document start");
		YamlDotNet.Core.Events.StreamEnd result = new YamlDotNet.Core.Events.StreamEnd(token.Start, token.End);
		if (scanner.MoveNextWithoutConsuming())
		{
			throw new InvalidOperationException("The scanner should contain no more tokens.");
		}
		return result;
	}

	private VersionDirective? ProcessDirectives(TagDirectiveCollection tags)
	{
		bool flag = false;
		VersionDirective result = null;
		while (true)
		{
			if (GetCurrentToken() is VersionDirective versionDirective)
			{
				if (version != null)
				{
					throw new SemanticErrorException(versionDirective.Start, versionDirective.End, "Found duplicate %YAML directive.");
				}
				if (versionDirective.Version.Major != 1 || versionDirective.Version.Minor > 3)
				{
					throw new SemanticErrorException(versionDirective.Start, versionDirective.End, "Found incompatible YAML document.");
				}
				result = (version = versionDirective);
				flag = true;
			}
			else
			{
				if (!(GetCurrentToken() is TagDirective tagDirective))
				{
					break;
				}
				if (tags.Contains(tagDirective.Handle))
				{
					throw new SemanticErrorException(tagDirective.Start, tagDirective.End, "Found duplicate %TAG directive.");
				}
				tags.Add(tagDirective);
				flag = true;
			}
			Skip();
		}
		if (GetCurrentToken() is YamlDotNet.Core.Tokens.DocumentStart && (version == null || (version.Version.Major == 1 && version.Version.Minor > 1)))
		{
			if (GetCurrentToken() is YamlDotNet.Core.Tokens.DocumentStart && version == null)
			{
				version = new VersionDirective(new Version(1, 2));
			}
			flag = true;
		}
		AddTagDirectives(tags, Constants.DefaultTagDirectives);
		if (flag)
		{
			tagDirectives.Clear();
		}
		AddTagDirectives(tagDirectives, tags);
		return result;
	}

	private static void AddTagDirectives(TagDirectiveCollection directives, IEnumerable<TagDirective> source)
	{
		foreach (TagDirective item in source)
		{
			if (!directives.Contains(item))
			{
				directives.Add(item);
			}
		}
	}

	private ParsingEvent ParseDocumentContent()
	{
		if (GetCurrentToken() is VersionDirective || GetCurrentToken() is TagDirective || GetCurrentToken() is YamlDotNet.Core.Tokens.DocumentStart || GetCurrentToken() is YamlDotNet.Core.Tokens.DocumentEnd || GetCurrentToken() is YamlDotNet.Core.Tokens.StreamEnd)
		{
			state = states.Pop();
			return ProcessEmptyScalar(scanner.CurrentPosition);
		}
		return ParseNode(isBlock: true, isIndentlessSequence: false);
	}

	private static ParsingEvent ProcessEmptyScalar(in Mark position)
	{
		return new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, string.Empty, ScalarStyle.Plain, isPlainImplicit: true, isQuotedImplicit: false, position, position);
	}

	private ParsingEvent ParseNode(bool isBlock, bool isIndentlessSequence)
	{
		if (GetCurrentToken() is Error { Start: var start } error)
		{
			throw new SemanticErrorException(in start, error.End, error.Value);
		}
		Token token = GetCurrentToken() ?? throw new SemanticErrorException("Reached the end of the stream while parsing a node");
		if (token is YamlDotNet.Core.Tokens.AnchorAlias anchorAlias)
		{
			state = states.Pop();
			YamlDotNet.Core.Events.AnchorAlias result = new YamlDotNet.Core.Events.AnchorAlias(anchorAlias.Value, anchorAlias.Start, anchorAlias.End);
			Skip();
			return result;
		}
		Mark start2 = token.Start;
		AnchorName anchor = AnchorName.Empty;
		TagName tag = TagName.Empty;
		Anchor anchor2 = null;
		Tag tag2 = null;
		while (true)
		{
			if (anchor.IsEmpty && token is Anchor anchor3)
			{
				anchor2 = anchor3;
				anchor = anchor3.Value;
				Skip();
			}
			else
			{
				if (!tag.IsEmpty || !(token is Tag tag3))
				{
					if (token is Anchor { Start: var start3 } anchor4)
					{
						throw new SemanticErrorException(in start3, anchor4.End, "While parsing a node, found more than one anchor.");
					}
					if (token is YamlDotNet.Core.Tokens.AnchorAlias { Start: var start4 } anchorAlias2)
					{
						throw new SemanticErrorException(in start4, anchorAlias2.End, "While parsing a node, did not find expected token.");
					}
					if (!(token is Error error2))
					{
						break;
					}
					if (tag2 != null && anchor2 != null && !anchor.IsEmpty)
					{
						return new YamlDotNet.Core.Events.Scalar(anchor, default(TagName), string.Empty, ScalarStyle.Any, isPlainImplicit: false, isQuotedImplicit: false, anchor2.Start, anchor2.End);
					}
					throw new SemanticErrorException(error2.Start, error2.End, error2.Value);
				}
				tag2 = tag3;
				if (string.IsNullOrEmpty(tag3.Handle))
				{
					tag = new TagName(tag3.Suffix);
				}
				else
				{
					if (!tagDirectives.Contains(tag3.Handle))
					{
						throw new SemanticErrorException(tag3.Start, tag3.End, "While parsing a node, found undefined tag handle.");
					}
					tag = new TagName(tagDirectives[tag3.Handle].Prefix + tag3.Suffix);
				}
				Skip();
			}
			token = GetCurrentToken() ?? throw new SemanticErrorException("Reached the end of the stream while parsing a node");
		}
		bool isEmpty = tag.IsEmpty;
		if (isIndentlessSequence && GetCurrentToken() is BlockEntry)
		{
			state = ParserState.IndentlessSequenceEntry;
			return new SequenceStart(anchor, tag, isEmpty, SequenceStyle.Block, start2, token.End);
		}
		if (token is YamlDotNet.Core.Tokens.Scalar scalar)
		{
			bool isPlainImplicit = false;
			bool isQuotedImplicit = false;
			if ((scalar.Style == ScalarStyle.Plain && tag.IsEmpty) || tag.IsNonSpecific)
			{
				isPlainImplicit = true;
			}
			else if (tag.IsEmpty)
			{
				isQuotedImplicit = true;
			}
			state = states.Pop();
			Skip();
			YamlDotNet.Core.Events.Scalar result2 = new YamlDotNet.Core.Events.Scalar(anchor, tag, scalar.Value, scalar.Style, isPlainImplicit, isQuotedImplicit, start2, scalar.End, scalar.IsKey);
			if (!anchor.IsEmpty && scanner.MoveNextWithoutConsuming())
			{
				currentToken = scanner.Current;
				if (currentToken is Error)
				{
					Error error3 = currentToken as Error;
					throw new SemanticErrorException(error3.Start, error3.End, error3.Value);
				}
			}
			if (state == ParserState.FlowMappingKey && scanner.MoveNextWithoutConsuming())
			{
				currentToken = scanner.Current;
				if (currentToken != null && !(currentToken is FlowEntry) && !(currentToken is FlowMappingEnd))
				{
					throw new SemanticErrorException(currentToken.Start, currentToken.End, "While parsing a flow mapping, did not find expected ',' or '}'.");
				}
			}
			return result2;
		}
		if (token is FlowSequenceStart flowSequenceStart)
		{
			state = ParserState.FlowSequenceFirstEntry;
			return new SequenceStart(anchor, tag, isEmpty, SequenceStyle.Flow, start2, flowSequenceStart.End);
		}
		if (token is FlowMappingStart flowMappingStart)
		{
			state = ParserState.FlowMappingFirstKey;
			return new MappingStart(anchor, tag, isEmpty, MappingStyle.Flow, start2, flowMappingStart.End);
		}
		if (isBlock)
		{
			if (token is BlockSequenceStart blockSequenceStart)
			{
				state = ParserState.BlockSequenceFirstEntry;
				return new SequenceStart(anchor, tag, isEmpty, SequenceStyle.Block, start2, blockSequenceStart.End);
			}
			if (token is BlockMappingStart blockMappingStart)
			{
				state = ParserState.BlockMappingFirstKey;
				return new MappingStart(anchor, tag, isEmpty, MappingStyle.Block, start2, blockMappingStart.End);
			}
		}
		if (!anchor.IsEmpty || !tag.IsEmpty)
		{
			state = states.Pop();
			return new YamlDotNet.Core.Events.Scalar(anchor, tag, string.Empty, ScalarStyle.Plain, isEmpty, isQuotedImplicit: false, start2, token.End);
		}
		throw new SemanticErrorException(token.Start, token.End, "While parsing a node, did not find expected node content.");
	}

	private ParsingEvent ParseDocumentEnd()
	{
		Token token = GetCurrentToken() ?? throw new SemanticErrorException("Reached the end of the stream while parsing a document end");
		bool isImplicit = true;
		Mark start = token.Start;
		Mark end = start;
		if (token is YamlDotNet.Core.Tokens.DocumentEnd)
		{
			end = token.End;
			Skip();
			isImplicit = false;
		}
		else if (!(currentToken is YamlDotNet.Core.Tokens.StreamEnd) && !(currentToken is YamlDotNet.Core.Tokens.DocumentStart) && !(currentToken is FlowSequenceEnd) && !(currentToken is VersionDirective) && (!(Current is YamlDotNet.Core.Events.Scalar) || !(currentToken is Error)))
		{
			throw new SemanticErrorException(in start, in end, "Did not find expected <document end>.");
		}
		if (version != null && version.Version.Major == 1 && version.Version.Minor > 1)
		{
			version = null;
		}
		state = ParserState.DocumentStart;
		return new YamlDotNet.Core.Events.DocumentEnd(isImplicit, start, end);
	}

	private ParsingEvent ParseBlockSequenceEntry(bool isFirst)
	{
		if (isFirst)
		{
			GetCurrentToken();
			Skip();
		}
		Token token = GetCurrentToken();
		if (token is BlockEntry { End: var position })
		{
			Skip();
			token = GetCurrentToken();
			if (!(token is BlockEntry) && !(token is BlockEnd))
			{
				states.Push(ParserState.BlockSequenceEntry);
				return ParseNode(isBlock: true, isIndentlessSequence: false);
			}
			state = ParserState.BlockSequenceEntry;
			return ProcessEmptyScalar(in position);
		}
		if (token is BlockEnd blockEnd)
		{
			state = states.Pop();
			SequenceEnd result = new SequenceEnd(blockEnd.Start, blockEnd.End);
			Skip();
			return result;
		}
		throw new SemanticErrorException(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty, "While parsing a block collection, did not find expected '-' indicator.");
	}

	private ParsingEvent ParseIndentlessSequenceEntry()
	{
		Token token = GetCurrentToken();
		if (token is BlockEntry { End: var position })
		{
			Skip();
			token = GetCurrentToken();
			if (!(token is BlockEntry) && !(token is Key) && !(token is Value) && !(token is BlockEnd))
			{
				states.Push(ParserState.IndentlessSequenceEntry);
				return ParseNode(isBlock: true, isIndentlessSequence: false);
			}
			state = ParserState.IndentlessSequenceEntry;
			return ProcessEmptyScalar(in position);
		}
		state = states.Pop();
		return new SequenceEnd(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty);
	}

	private ParsingEvent ParseBlockMappingKey(bool isFirst)
	{
		if (isFirst)
		{
			GetCurrentToken();
			Skip();
		}
		Token token = GetCurrentToken();
		if (token is Key { End: var position })
		{
			Skip();
			token = GetCurrentToken();
			if (!(token is Key) && !(token is Value) && !(token is BlockEnd))
			{
				states.Push(ParserState.BlockMappingValue);
				return ParseNode(isBlock: true, isIndentlessSequence: true);
			}
			state = ParserState.BlockMappingValue;
			return ProcessEmptyScalar(in position);
		}
		if (token is Value value)
		{
			Skip();
			return ProcessEmptyScalar(value.End);
		}
		if (token is YamlDotNet.Core.Tokens.AnchorAlias anchorAlias)
		{
			Skip();
			return new YamlDotNet.Core.Events.AnchorAlias(anchorAlias.Value, anchorAlias.Start, anchorAlias.End);
		}
		if (token is BlockEnd blockEnd)
		{
			state = states.Pop();
			MappingEnd result = new MappingEnd(blockEnd.Start, blockEnd.End);
			Skip();
			return result;
		}
		if (GetCurrentToken() is Error { Start: var start } error)
		{
			throw new SyntaxErrorException(in start, error.End, error.Value);
		}
		throw new SemanticErrorException(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty, "While parsing a block mapping, did not find expected key.");
	}

	private ParsingEvent ParseBlockMappingValue()
	{
		Token token = GetCurrentToken();
		if (token is Value { End: var position })
		{
			Skip();
			token = GetCurrentToken();
			if (!(token is Key) && !(token is Value) && !(token is BlockEnd))
			{
				states.Push(ParserState.BlockMappingKey);
				return ParseNode(isBlock: true, isIndentlessSequence: true);
			}
			state = ParserState.BlockMappingKey;
			return ProcessEmptyScalar(in position);
		}
		if (token is Error { Start: var start } error)
		{
			throw new SemanticErrorException(in start, error.End, error.Value);
		}
		state = ParserState.BlockMappingKey;
		return ProcessEmptyScalar(token?.Start ?? Mark.Empty);
	}

	private ParsingEvent ParseFlowSequenceEntry(bool isFirst)
	{
		if (isFirst)
		{
			GetCurrentToken();
			Skip();
		}
		Token token = GetCurrentToken();
		if (!(token is FlowSequenceEnd))
		{
			if (!isFirst)
			{
				if (!(token is FlowEntry))
				{
					throw new SemanticErrorException(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty, "While parsing a flow sequence, did not find expected ',' or ']'.");
				}
				Skip();
				token = GetCurrentToken();
			}
			if (token is Key)
			{
				state = ParserState.FlowSequenceEntryMappingKey;
				MappingStart result = new MappingStart(AnchorName.Empty, TagName.Empty, isImplicit: true, MappingStyle.Flow);
				Skip();
				return result;
			}
			if (!(token is FlowSequenceEnd))
			{
				states.Push(ParserState.FlowSequenceEntry);
				return ParseNode(isBlock: false, isIndentlessSequence: false);
			}
		}
		state = states.Pop();
		SequenceEnd result2 = new SequenceEnd(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty);
		Skip();
		return result2;
	}

	private ParsingEvent ParseFlowSequenceEntryMappingKey()
	{
		Token token = GetCurrentToken();
		if (!(token is Value) && !(token is FlowEntry) && !(token is FlowSequenceEnd))
		{
			states.Push(ParserState.FlowSequenceEntryMappingValue);
			return ParseNode(isBlock: false, isIndentlessSequence: false);
		}
		Mark position = token?.End ?? Mark.Empty;
		Skip();
		state = ParserState.FlowSequenceEntryMappingValue;
		return ProcessEmptyScalar(in position);
	}

	private ParsingEvent ParseFlowSequenceEntryMappingValue()
	{
		Token token = GetCurrentToken();
		if (token is Value)
		{
			Skip();
			token = GetCurrentToken();
			if (!(token is FlowEntry) && !(token is FlowSequenceEnd))
			{
				states.Push(ParserState.FlowSequenceEntryMappingEnd);
				return ParseNode(isBlock: false, isIndentlessSequence: false);
			}
		}
		state = ParserState.FlowSequenceEntryMappingEnd;
		return ProcessEmptyScalar(token?.Start ?? Mark.Empty);
	}

	private ParsingEvent ParseFlowSequenceEntryMappingEnd()
	{
		state = ParserState.FlowSequenceEntry;
		Token token = GetCurrentToken();
		return new MappingEnd(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty);
	}

	private ParsingEvent ParseFlowMappingKey(bool isFirst)
	{
		if (isFirst)
		{
			GetCurrentToken();
			Skip();
		}
		Token token = GetCurrentToken();
		if (!(token is FlowMappingEnd))
		{
			if (!isFirst)
			{
				if (token is FlowEntry)
				{
					Skip();
					token = GetCurrentToken();
				}
				else if (!(token is YamlDotNet.Core.Tokens.Scalar))
				{
					throw new SemanticErrorException(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty, "While parsing a flow mapping,  did not find expected ',' or '}'.");
				}
			}
			if (token is Key)
			{
				Skip();
				token = GetCurrentToken();
				if (!(token is Value) && !(token is FlowEntry) && !(token is FlowMappingEnd))
				{
					states.Push(ParserState.FlowMappingValue);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
				state = ParserState.FlowMappingValue;
				return ProcessEmptyScalar(token?.Start ?? Mark.Empty);
			}
			if (token is YamlDotNet.Core.Tokens.Scalar)
			{
				states.Push(ParserState.FlowMappingValue);
				return ParseNode(isBlock: false, isIndentlessSequence: false);
			}
			if (!(token is FlowMappingEnd))
			{
				states.Push(ParserState.FlowMappingEmptyValue);
				return ParseNode(isBlock: false, isIndentlessSequence: false);
			}
		}
		state = states.Pop();
		Skip();
		return new MappingEnd(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty);
	}

	private ParsingEvent ParseFlowMappingValue(bool isEmpty)
	{
		Token token = GetCurrentToken();
		if (!isEmpty && token is Value)
		{
			Skip();
			token = GetCurrentToken();
			if (!(token is FlowEntry) && !(token is FlowMappingEnd))
			{
				states.Push(ParserState.FlowMappingKey);
				return ParseNode(isBlock: false, isIndentlessSequence: false);
			}
		}
		state = ParserState.FlowMappingKey;
		if (!isEmpty && token is YamlDotNet.Core.Tokens.Scalar scalar)
		{
			Skip();
			return new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, scalar.Value, scalar.Style, isPlainImplicit: false, isQuotedImplicit: false, token.Start, scalar.End);
		}
		return ProcessEmptyScalar(token?.Start ?? Mark.Empty);
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.ParserExtensions ----
namespace YamlDotNet.Core
{
internal static class ParserExtensions
{
	public static T Consume<T>(this IParser parser) where T : ParsingEvent
	{
		T result = parser.Require<T>();
		parser.MoveNext();
		return result;
	}

	public static bool TryConsume<T>(this IParser parser, [MaybeNullWhen(false)] out T @event) where T : ParsingEvent
	{
		if (parser.Accept<T>(out @event))
		{
			parser.MoveNext();
			return true;
		}
		return false;
	}

	public static T Require<T>(this IParser parser) where T : ParsingEvent
	{
		if (!parser.Accept<T>(out var @event))
		{
			ParsingEvent current = parser.Current;
			if (current == null)
			{
				throw new YamlException("Expected '" + typeof(T).Name + "', got nothing.");
			}
			throw new YamlException(current.Start, current.End, $"Expected '{typeof(T).Name}', got '{current.GetType().Name}' (at {current.Start}).");
		}
		return @event;
	}

	public static bool Accept<T>(this IParser parser, [MaybeNullWhen(false)] out T @event) where T : ParsingEvent
	{
		if (parser.Current == null && !parser.MoveNext())
		{
			throw new EndOfStreamException();
		}
		if (parser.Current is T val)
		{
			@event = val;
			return true;
		}
		@event = null;
		return false;
	}

	public static void SkipThisAndNestedEvents(this IParser parser)
	{
		int num = 0;
		do
		{
			ParsingEvent parsingEvent = parser.Consume<ParsingEvent>();
			num += parsingEvent.NestingIncrease;
		}
		while (num > 0);
	}

	[Obsolete("Please use Consume<T>() instead")]
	public static T Expect<T>(this IParser parser) where T : ParsingEvent
	{
		return parser.Consume<T>();
	}

	[Obsolete("Please use TryConsume<T>(out var evt) instead")]
	[return: MaybeNull]
	public static T? Allow<T>(this IParser parser) where T : ParsingEvent
	{
		if (!parser.TryConsume<T>(out var @event))
		{
			return null;
		}
		return @event;
	}

	[Obsolete("Please use Accept<T>(out var evt) instead")]
	[return: MaybeNull]
	public static T? Peek<T>(this IParser parser) where T : ParsingEvent
	{
		if (!parser.Accept<T>(out var @event))
		{
			return null;
		}
		return @event;
	}

	[Obsolete("Please use TryConsume<T>(out var evt) or Accept<T>(out var evt) instead")]
	public static bool Accept<T>(this IParser parser) where T : ParsingEvent
	{
		T @event;
		return parser.Accept<T>(out @event);
	}

	public static bool TryFindMappingEntry(this IParser parser, Func<Scalar, bool> selector, [MaybeNullWhen(false)] out Scalar? key, [MaybeNullWhen(false)] out ParsingEvent? value)
	{
		if (parser.TryConsume<MappingStart>(out var _))
		{
			while (parser.Current != null)
			{
				ParsingEvent current = parser.Current;
				if (!(current is Scalar scalar))
				{
					if (current is MappingStart || current is SequenceStart)
					{
						parser.SkipThisAndNestedEvents();
					}
					else
					{
						parser.MoveNext();
					}
					continue;
				}
				bool num = selector(scalar);
				parser.MoveNext();
				if (num)
				{
					value = parser.Current;
					key = scalar;
					return true;
				}
				parser.SkipThisAndNestedEvents();
			}
		}
		key = null;
		value = null;
		return false;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.ParserState ----
namespace YamlDotNet.Core
{
internal enum ParserState
{
	StreamStart,
	StreamEnd,
	ImplicitDocumentStart,
	DocumentStart,
	DocumentContent,
	DocumentEnd,
	BlockNode,
	BlockNodeOrIndentlessSequence,
	FlowNode,
	BlockSequenceFirstEntry,
	BlockSequenceEntry,
	IndentlessSequenceEntry,
	BlockMappingFirstKey,
	BlockMappingKey,
	BlockMappingValue,
	FlowSequenceFirstEntry,
	FlowSequenceEntry,
	FlowSequenceEntryMappingKey,
	FlowSequenceEntryMappingValue,
	FlowSequenceEntryMappingEnd,
	FlowMappingFirstKey,
	FlowMappingKey,
	FlowMappingValue,
	FlowMappingEmptyValue
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.RecursionLevel ----
namespace YamlDotNet.Core
{
internal sealed class RecursionLevel
{
	private int current;

	public int Maximum { get; }

	public RecursionLevel(int maximum)
	{
		Maximum = maximum;
	}

	public void Increment()
	{
		if (!TryIncrement())
		{
			throw new MaximumRecursionLevelReachedException("Maximum level of recursion reached");
		}
	}

	public bool TryIncrement()
	{
		if (current < Maximum)
		{
			current++;
			return true;
		}
		return false;
	}

	public void Decrement()
	{
		if (current == 0)
		{
			throw new InvalidOperationException("Attempted to decrement RecursionLevel to a negative value");
		}
		current--;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.ScalarStyle ----
namespace YamlDotNet.Core
{
internal enum ScalarStyle
{
	Any,
	Plain,
	SingleQuoted,
	DoubleQuoted,
	Literal,
	Folded
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Scanner ----
namespace YamlDotNet.Core
{
internal class Scanner : IScanner
{
	private const int MaxVersionNumberLength = 9;

	private static readonly SortedDictionary<char, char> SimpleEscapeCodes = new SortedDictionary<char, char>
	{
		{ '0', '\0' },
		{ 'a', '\a' },
		{ 'b', '\b' },
		{ 't', '\t' },
		{ '\t', '\t' },
		{ 'n', '\n' },
		{ 'v', '\v' },
		{ 'f', '\f' },
		{ 'r', '\r' },
		{ 'e', '\u001b' },
		{ ' ', ' ' },
		{ '"', '"' },
		{ '\\', '\\' },
		{ '/', '/' },
		{ 'N', '\u0085' },
		{ '_', '\u00a0' },
		{ 'L', '\u2028' },
		{ 'P', '\u2029' }
	};

	private readonly Stack<int> indents = new Stack<int>();

	private readonly InsertionQueue<Token> tokens = new InsertionQueue<Token>();

	private readonly Stack<SimpleKey> simpleKeys = new Stack<SimpleKey>();

	private readonly CharacterAnalyzer<LookAheadBuffer> analyzer;

	private readonly Cursor cursor;

	private bool streamStartProduced;

	private bool streamEndProduced;

	private bool plainScalarFollowedByComment;

	private int flowSequenceStartLine;

	private bool flowCollectionFetched;

	private bool startFlowCollectionFetched;

	private int indent = -1;

	private bool flowScalarFetched;

	private bool simpleKeyAllowed;

	private int flowLevel;

	private int tokensParsed;

	private bool tokenAvailable;

	private Token? previous;

	private Anchor? previousAnchor;

	private Scalar? lastScalar;

	private static readonly byte[] EmptyBytes = new byte[0];

	public bool SkipComments { get; private set; }

	public Token? Current { get; private set; }

	public Mark CurrentPosition => cursor.Mark();

	private bool IsDocumentStart()
	{
		if (!analyzer.EndOfInput && cursor.LineOffset == 0 && analyzer.Check('-') && analyzer.Check('-', 1) && analyzer.Check('-', 2))
		{
			return analyzer.IsWhiteBreakOrZero(3);
		}
		return false;
	}

	private bool IsDocumentEnd()
	{
		if (!analyzer.EndOfInput && cursor.LineOffset == 0 && analyzer.Check('.') && analyzer.Check('.', 1) && analyzer.Check('.', 2))
		{
			return analyzer.IsWhiteBreakOrZero(3);
		}
		return false;
	}

	private bool IsDocumentIndicator()
	{
		if (!IsDocumentStart())
		{
			return IsDocumentEnd();
		}
		return true;
	}

	public Scanner(TextReader input, bool skipComments = true)
	{
		analyzer = new CharacterAnalyzer<LookAheadBuffer>(new LookAheadBuffer(input, 1024));
		cursor = new Cursor();
		SkipComments = skipComments;
	}

	public bool MoveNext()
	{
		if (Current != null)
		{
			ConsumeCurrent();
		}
		return MoveNextWithoutConsuming();
	}

	public bool MoveNextWithoutConsuming()
	{
		if (!tokenAvailable && !streamEndProduced)
		{
			FetchMoreTokens();
		}
		if (tokens.Count > 0)
		{
			Current = tokens.Dequeue();
			tokenAvailable = false;
			return true;
		}
		Current = null;
		return false;
	}

	public void ConsumeCurrent()
	{
		tokensParsed++;
		tokenAvailable = false;
		previous = Current;
		Current = null;
	}

	private char ReadCurrentCharacter()
	{
		char result = analyzer.Peek(0);
		Skip();
		return result;
	}

	private char ReadLine()
	{
		if (analyzer.Check("\r\n\u0085"))
		{
			SkipLine();
			return '\n';
		}
		char result = analyzer.Peek(0);
		SkipLine();
		return result;
	}

	private void FetchMoreTokens()
	{
		while (true)
		{
			bool flag = false;
			if (tokens.Count == 0)
			{
				flag = true;
			}
			else
			{
				foreach (SimpleKey simpleKey in simpleKeys)
				{
					if (simpleKey.IsPossible && simpleKey.TokenNumber == tokensParsed)
					{
						flag = true;
						break;
					}
				}
			}
			if (!flag)
			{
				break;
			}
			FetchNextToken();
		}
		tokenAvailable = true;
	}

	private static bool StartsWith(StringBuilder what, char start)
	{
		if (what.Length > 0)
		{
			return what[0] == start;
		}
		return false;
	}

	private void StaleSimpleKeys()
	{
		foreach (SimpleKey simpleKey in simpleKeys)
		{
			if (simpleKey.IsPossible && (simpleKey.Line < cursor.Line || simpleKey.Index + 1024 < cursor.Index))
			{
				if (simpleKey.IsRequired)
				{
					Mark mark = cursor.Mark();
					tokens.Enqueue(new Error("While scanning a simple key, could not find expected ':'.", mark, mark));
				}
				simpleKey.MarkAsImpossible();
			}
		}
	}

	private void FetchNextToken()
	{
		if (!streamStartProduced)
		{
			FetchStreamStart();
			return;
		}
		ScanToNextToken();
		StaleSimpleKeys();
		UnrollIndent(cursor.LineOffset);
		analyzer.Buffer.Cache(4);
		if (analyzer.Buffer.EndOfInput)
		{
			lastScalar = null;
			FetchStreamEnd();
		}
		if (cursor.LineOffset == 0 && analyzer.Check('%'))
		{
			lastScalar = null;
			FetchDirective();
			return;
		}
		if (IsDocumentStart())
		{
			lastScalar = null;
			FetchDocumentIndicator(isStartToken: true);
			return;
		}
		if (IsDocumentEnd())
		{
			lastScalar = null;
			FetchDocumentIndicator(isStartToken: false);
			return;
		}
		if (analyzer.Check('['))
		{
			lastScalar = null;
			FetchFlowCollectionStart(isSequenceToken: true);
			return;
		}
		if (analyzer.Check('{'))
		{
			lastScalar = null;
			FetchFlowCollectionStart(isSequenceToken: false);
			return;
		}
		if (analyzer.Check(']'))
		{
			lastScalar = null;
			FetchFlowCollectionEnd(isSequenceToken: true);
			return;
		}
		if (analyzer.Check('}'))
		{
			lastScalar = null;
			FetchFlowCollectionEnd(isSequenceToken: false);
			return;
		}
		if (analyzer.Check(','))
		{
			lastScalar = null;
			FetchFlowEntry();
			return;
		}
		if (analyzer.Check('-'))
		{
			if (analyzer.IsWhiteBreakOrZero(1))
			{
				FetchBlockEntry();
				return;
			}
			if (flowLevel > 0 && analyzer.Check(",[]{}", 1))
			{
				tokens.Enqueue(new Error("Invalid key indicator format.", cursor.Mark(), cursor.Mark()));
			}
		}
		if (analyzer.Check('?') && (flowLevel > 0 || analyzer.IsWhiteBreakOrZero(1)) && analyzer.IsWhiteBreakOrZero(1))
		{
			FetchKey();
		}
		else if (analyzer.Check(':') && (flowLevel > 0 || analyzer.IsWhiteBreakOrZero(1)) && (!simpleKeyAllowed || flowLevel <= 0) && (!flowScalarFetched || !analyzer.Check(':', 1)) && (analyzer.IsWhiteBreakOrZero(1) || analyzer.Check(',', 1) || flowScalarFetched || flowCollectionFetched || startFlowCollectionFetched))
		{
			if (lastScalar != null)
			{
				lastScalar.IsKey = true;
				lastScalar = null;
			}
			FetchValue();
		}
		else if (analyzer.Check('*'))
		{
			FetchAnchor(isAlias: true);
		}
		else if (analyzer.Check('&'))
		{
			FetchAnchor(isAlias: false);
		}
		else if (analyzer.Check('!'))
		{
			FetchTag();
		}
		else if (analyzer.Check('|') && flowLevel == 0)
		{
			FetchBlockScalar(isLiteral: true);
		}
		else if (analyzer.Check('>') && flowLevel == 0)
		{
			FetchBlockScalar(isLiteral: false);
		}
		else if (analyzer.Check('\''))
		{
			FetchQuotedScalar(isSingleQuoted: true);
		}
		else if (analyzer.Check('"'))
		{
			FetchQuotedScalar(isSingleQuoted: false);
		}
		else if ((!analyzer.IsWhiteBreakOrZero() && !analyzer.Check("-?:,[]{}#&*!|>'\"%@`")) || (analyzer.Check('-') && !analyzer.IsWhite(1)) || (analyzer.Check("?:") && !analyzer.IsWhiteBreakOrZero(1)) || (simpleKeyAllowed && flowLevel > 0))
		{
			if (plainScalarFollowedByComment)
			{
				Mark mark = cursor.Mark();
				tokens.Enqueue(new Error("While scanning plain scalar, found a comment between adjacent scalars.", mark, mark));
			}
			if ((flowScalarFetched || (flowCollectionFetched && !startFlowCollectionFetched)) && analyzer.Check(':'))
			{
				Skip();
			}
			flowScalarFetched = false;
			flowCollectionFetched = false;
			startFlowCollectionFetched = false;
			plainScalarFollowedByComment = false;
			FetchPlainScalar();
		}
		else
		{
			if (simpleKeyAllowed && indent >= cursor.LineOffset && analyzer.IsTab())
			{
				throw new SyntaxErrorException("While scanning a mapping, found invalid tab as indentation.");
			}
			if (!analyzer.IsWhiteBreakOrZero())
			{
				Mark start = cursor.Mark();
				Skip();
				throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning for the next token, found character that cannot start any token.");
			}
			Skip();
		}
	}

	private bool CheckWhiteSpace()
	{
		if (!analyzer.Check(' '))
		{
			if (flowLevel > 0 || !simpleKeyAllowed)
			{
				return analyzer.Check('\t');
			}
			return false;
		}
		return true;
	}

	private void Skip()
	{
		cursor.Skip();
		analyzer.Buffer.Skip(1);
	}

	private void SkipLine()
	{
		if (analyzer.IsCrLf())
		{
			cursor.SkipLineByOffset(2);
			analyzer.Buffer.Skip(2);
		}
		else if (analyzer.IsBreak())
		{
			cursor.SkipLineByOffset(1);
			analyzer.Buffer.Skip(1);
		}
		else if (!analyzer.IsZero())
		{
			throw new InvalidOperationException("Not at a break.");
		}
	}

	private void ScanToNextToken()
	{
		while (true)
		{
			if (CheckWhiteSpace())
			{
				Skip();
				continue;
			}
			ProcessComment();
			if (analyzer.IsBreak())
			{
				SkipLine();
				if (flowLevel == 0)
				{
					simpleKeyAllowed = true;
				}
				continue;
			}
			break;
		}
	}

	private void ProcessComment()
	{
		if (!analyzer.Check('#'))
		{
			return;
		}
		Mark start = cursor.Mark();
		Skip();
		while (analyzer.IsSpace())
		{
			Skip();
		}
		StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
		try
		{
			StringBuilder builder = builderWrapper.Builder;
			while (!analyzer.IsBreakOrZero())
			{
				builder.Append(ReadCurrentCharacter());
			}
			if (!SkipComments)
			{
				bool isInline = previous != null && previous.End.Line == start.Line && previous.End.Column != 1 && !(previous is StreamStart);
				tokens.Enqueue(new Comment(builder.ToString(), isInline, start, cursor.Mark()));
			}
		}
		finally
		{
			((IDisposable)builderWrapper/*cast due to constrained. prefix*//*cast due to constrained. prefix*/).Dispose();
		}
	}

	private void FetchStreamStart()
	{
		simpleKeys.Push(new SimpleKey());
		simpleKeyAllowed = true;
		streamStartProduced = true;
		Mark start = cursor.Mark();
		tokens.Enqueue(new StreamStart(in start, in start));
	}

	private void UnrollIndent(int column)
	{
		if (flowLevel == 0)
		{
			while (indent > column)
			{
				Mark start = cursor.Mark();
				tokens.Enqueue(new BlockEnd(in start, in start));
				indent = indents.Pop();
			}
		}
	}

	private void FetchStreamEnd()
	{
		cursor.ForceSkipLineAfterNonBreak();
		UnrollIndent(-1);
		RemoveSimpleKey();
		simpleKeyAllowed = false;
		streamEndProduced = true;
		Mark start = cursor.Mark();
		tokens.Enqueue(new StreamEnd(in start, in start));
	}

	private void FetchDirective()
	{
		UnrollIndent(-1);
		RemoveSimpleKey();
		simpleKeyAllowed = false;
		Token token = ScanDirective();
		if (token != null)
		{
			tokens.Enqueue(token);
		}
	}

	private Token? ScanDirective()
	{
		Mark start = cursor.Mark();
		Skip();
		string text = ScanDirectiveName(in start);
		Token result;
		if (!(text == "YAML"))
		{
			if (!(text == "TAG"))
			{
				while (!analyzer.EndOfInput && !analyzer.Check('#') && !analyzer.IsBreak())
				{
					Skip();
				}
				return null;
			}
			result = ScanTagDirectiveValue(in start);
		}
		else
		{
			if (!(previous is DocumentStart) && !(previous is StreamStart) && !(previous is DocumentEnd))
			{
				throw new SemanticErrorException(in start, cursor.Mark(), "While scanning a version directive, did not find preceding <document end>.");
			}
			result = ScanVersionDirectiveValue(in start);
		}
		while (analyzer.IsWhite())
		{
			Skip();
		}
		ProcessComment();
		if (!analyzer.IsBreakOrZero())
		{
			throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a directive, did not find expected comment or line break.");
		}
		if (analyzer.IsBreak())
		{
			SkipLine();
		}
		return result;
	}

	private void FetchDocumentIndicator(bool isStartToken)
	{
		UnrollIndent(-1);
		RemoveSimpleKey();
		simpleKeyAllowed = false;
		Mark start = cursor.Mark();
		Skip();
		Skip();
		Skip();
		if (isStartToken)
		{
			tokens.Enqueue(new DocumentStart(in start, cursor.Mark()));
			return;
		}
		Token token = null;
		while (!analyzer.EndOfInput && !analyzer.IsBreak() && !analyzer.Check('#'))
		{
			if (!analyzer.IsWhite())
			{
				token = new Error("While scanning a document end, found invalid content after '...' marker.", start, cursor.Mark());
				break;
			}
			Skip();
		}
		tokens.Enqueue(new DocumentEnd(in start, in start));
		if (token != null)
		{
			tokens.Enqueue(token);
		}
	}

	private void FetchFlowCollectionStart(bool isSequenceToken)
	{
		SaveSimpleKey();
		IncreaseFlowLevel();
		simpleKeyAllowed = true;
		Mark start = cursor.Mark();
		Skip();
		Token token;
		if (isSequenceToken)
		{
			token = new FlowSequenceStart(in start, in start);
			flowSequenceStartLine = token.Start.Line;
		}
		else
		{
			token = new FlowMappingStart(in start, in start);
		}
		tokens.Enqueue(token);
		startFlowCollectionFetched = true;
	}

	private void IncreaseFlowLevel()
	{
		simpleKeys.Push(new SimpleKey());
		flowLevel++;
	}

	private void FetchFlowCollectionEnd(bool isSequenceToken)
	{
		RemoveSimpleKey();
		DecreaseFlowLevel();
		simpleKeyAllowed = false;
		Mark start = cursor.Mark();
		Skip();
		Token token = null;
		Token item;
		if (isSequenceToken)
		{
			if (analyzer.Check('#'))
			{
				token = new Error("While scanning a flow sequence end, found invalid comment after ']'.", start, start);
			}
			item = new FlowSequenceEnd(in start, in start);
		}
		else
		{
			item = new FlowMappingEnd(in start, in start);
		}
		tokens.Enqueue(item);
		if (token != null)
		{
			tokens.Enqueue(token);
		}
		flowCollectionFetched = true;
	}

	private void DecreaseFlowLevel()
	{
		if (flowLevel > 0)
		{
			flowLevel--;
			simpleKeys.Pop();
		}
	}

	private void FetchFlowEntry()
	{
		RemoveSimpleKey();
		simpleKeyAllowed = true;
		Mark start = cursor.Mark();
		Skip();
		Mark end = cursor.Mark();
		if (analyzer.Check('#'))
		{
			tokens.Enqueue(new Error("While scanning a flow entry, found invalid comment after comma.", start, end));
		}
		else
		{
			tokens.Enqueue(new FlowEntry(in start, in end));
		}
	}

	private void FetchBlockEntry()
	{
		if (flowLevel == 0)
		{
			if (!simpleKeyAllowed)
			{
				if (previousAnchor != null && previousAnchor.End.Line == cursor.Line)
				{
					throw new SemanticErrorException(previousAnchor.Start, previousAnchor.End, "Anchor before sequence entry on same line is not allowed.");
				}
				Mark mark = cursor.Mark();
				tokens.Enqueue(new Error("Block sequence entries are not allowed in this context.", mark, mark));
			}
			RollIndent(cursor.LineOffset, -1, isSequence: true, cursor.Mark());
		}
		RemoveSimpleKey();
		simpleKeyAllowed = true;
		Mark start = cursor.Mark();
		Skip();
		tokens.Enqueue(new BlockEntry(in start, cursor.Mark()));
	}

	private void FetchKey()
	{
		if (flowLevel == 0)
		{
			if (!simpleKeyAllowed)
			{
				Mark start = cursor.Mark();
				throw new SyntaxErrorException(in start, in start, "Mapping keys are not allowed in this context.");
			}
			RollIndent(cursor.LineOffset, -1, isSequence: false, cursor.Mark());
		}
		RemoveSimpleKey();
		simpleKeyAllowed = flowLevel == 0;
		Mark start2 = cursor.Mark();
		Skip();
		tokens.Enqueue(new Key(in start2, cursor.Mark()));
	}

	private void FetchValue()
	{
		SimpleKey simpleKey = simpleKeys.Peek();
		if (simpleKey.IsPossible)
		{
			tokens.Insert(simpleKey.TokenNumber - tokensParsed, new Key(simpleKey.Mark, simpleKey.Mark));
			RollIndent(simpleKey.LineOffset, simpleKey.TokenNumber, isSequence: false, simpleKey.Mark);
			simpleKey.MarkAsImpossible();
			simpleKeyAllowed = false;
		}
		else
		{
			bool flag = flowLevel == 0;
			if (flag)
			{
				if (!simpleKeyAllowed)
				{
					Mark mark = cursor.Mark();
					tokens.Enqueue(new Error("Mapping values are not allowed in this context.", mark, mark));
					return;
				}
				RollIndent(cursor.LineOffset, -1, isSequence: false, cursor.Mark());
				if (cursor.LineOffset == 0 && simpleKey.LineOffset == 0)
				{
					tokens.Insert(tokens.Count, new Key(simpleKey.Mark, simpleKey.Mark));
					flag = false;
				}
			}
			simpleKeyAllowed = flag;
		}
		Mark start = cursor.Mark();
		Skip();
		tokens.Enqueue(new Value(in start, cursor.Mark()));
	}

	private void RollIndent(int column, int number, bool isSequence, Mark position)
	{
		if (flowLevel <= 0 && indent < column)
		{
			indents.Push(indent);
			indent = column;
			Token item = ((!isSequence) ? ((Token)new BlockMappingStart(in position, in position)) : ((Token)new BlockSequenceStart(in position, in position)));
			if (number == -1)
			{
				tokens.Enqueue(item);
			}
			else
			{
				tokens.Insert(number - tokensParsed, item);
			}
		}
	}

	private void FetchAnchor(bool isAlias)
	{
		SaveSimpleKey();
		simpleKeyAllowed = false;
		tokens.Enqueue(ScanAnchor(isAlias));
	}

	private Token ScanAnchor(bool isAlias)
	{
		Mark start = cursor.Mark();
		Skip();
		bool flag = false;
		if (isAlias)
		{
			SimpleKey simpleKey = simpleKeys.Peek();
			flag = simpleKey.IsRequired && simpleKey.IsPossible;
		}
		StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
		try
		{
			StringBuilder builder = builderWrapper.Builder;
			while (!analyzer.IsWhiteBreakOrZero() && !analyzer.Check("[]{},") && (!flag || !analyzer.Check(':') || !analyzer.IsWhiteBreakOrZero(1)))
			{
				builder.Append(ReadCurrentCharacter());
			}
			if (builder.Length == 0 || (!analyzer.IsWhiteBreakOrZero() && !analyzer.Check("?:,]}%@`")))
			{
				throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning an anchor or alias, found value containing disallowed: []{},");
			}
			AnchorName value = new AnchorName(builder.ToString());
			if (isAlias)
			{
				return new AnchorAlias(value, start, cursor.Mark());
			}
			return previousAnchor = new Anchor(value, start, cursor.Mark());
		}
		finally
		{
			((IDisposable)builderWrapper/*cast due to constrained. prefix*//*cast due to constrained. prefix*/).Dispose();
		}
	}

	private void FetchTag()
	{
		SaveSimpleKey();
		simpleKeyAllowed = false;
		tokens.Enqueue(ScanTag());
	}

	private Token ScanTag()
	{
		Mark start = cursor.Mark();
		string text;
		string text2;
		if (analyzer.Check('<', 1))
		{
			text = string.Empty;
			Skip();
			Skip();
			text2 = ScanTagUri(null, start);
			if (!analyzer.Check('>'))
			{
				throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a tag, did not find the expected '>'.");
			}
			Skip();
		}
		else
		{
			string text3 = ScanTagHandle(isDirective: false, start);
			if (text3.Length > 1 && text3[0] == '!' && text3[text3.Length - 1] == '!')
			{
				text = text3;
				text2 = ScanTagUri(null, start);
			}
			else
			{
				text2 = ScanTagUri(text3, start);
				text = "!";
				if (text2.Length == 0)
				{
					text2 = text;
					text = string.Empty;
				}
			}
		}
		if (!analyzer.IsWhiteBreakOrZero() && !analyzer.Check(','))
		{
			throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a tag, did not find expected whitespace, comma or line break.");
		}
		return new Tag(text, text2, start, cursor.Mark());
	}

	private void FetchBlockScalar(bool isLiteral)
	{
		SaveSimpleKey();
		simpleKeyAllowed = true;
		tokens.Enqueue(ScanBlockScalar(isLiteral));
	}

	private Token ScanBlockScalar(bool isLiteral)
	{
		StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
		try
		{
			StringBuilder builder = builderWrapper.Builder;
			StringBuilderPool.BuilderWrapper builderWrapper2 = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder2 = builderWrapper2.Builder;
				StringBuilderPool.BuilderWrapper builderWrapper3 = StringBuilderPool.Rent();
				try
				{
					StringBuilder builder3 = builderWrapper3.Builder;
					int num = 0;
					int num2 = 0;
					int currentIndent = 0;
					bool flag = false;
					bool? isFirstLine = null;
					Mark start = cursor.Mark();
					Skip();
					if (analyzer.Check("+-"))
					{
						num = (analyzer.Check('+') ? 1 : (-1));
						Skip();
						if (analyzer.IsDigit())
						{
							if (analyzer.Check('0'))
							{
								throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a block scalar, found an indentation indicator equal to 0.");
							}
							num2 = analyzer.AsDigit();
							Skip();
						}
					}
					else if (analyzer.IsDigit())
					{
						if (analyzer.Check('0'))
						{
							throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a block scalar, found an indentation indicator equal to 0.");
						}
						num2 = analyzer.AsDigit();
						Skip();
						if (analyzer.Check("+-"))
						{
							num = (analyzer.Check('+') ? 1 : (-1));
							Skip();
						}
					}
					if (analyzer.Check('#'))
					{
						throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a block scalar, found a comment without whtespace after '>' indicator.");
					}
					while (analyzer.IsWhite())
					{
						Skip();
					}
					ProcessComment();
					if (!analyzer.IsBreakOrZero())
					{
						throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a block scalar, did not find expected comment or line break.");
					}
					if (analyzer.IsBreak())
					{
						SkipLine();
						if (!isFirstLine.HasValue)
						{
							isFirstLine = true;
						}
						else if (isFirstLine == true)
						{
							isFirstLine = false;
						}
					}
					Mark end = cursor.Mark();
					if (num2 != 0)
					{
						currentIndent = ((indent >= 0) ? (indent + num2) : num2);
					}
					currentIndent = ScanBlockScalarBreaks(currentIndent, builder3, isLiteral, ref end, ref isFirstLine);
					isFirstLine = false;
					while (cursor.LineOffset == currentIndent && !analyzer.IsZero() && !IsDocumentEnd())
					{
						bool flag2 = analyzer.IsWhite();
						if (!isLiteral && StartsWith(builder2, '\n') && !flag && !flag2)
						{
							if (builder3.Length == 0)
							{
								builder.Append(' ');
							}
							builder2.Length = 0;
						}
						else
						{
							builder.Append(builder2.ToString());
							builder2.Length = 0;
						}
						builder.Append(builder3.ToString());
						builder3.Length = 0;
						flag = analyzer.IsWhite();
						while (!analyzer.IsBreakOrZero())
						{
							builder.Append(ReadCurrentCharacter());
						}
						char c = ReadLine();
						if (c != 0)
						{
							builder2.Append(c);
						}
						currentIndent = ScanBlockScalarBreaks(currentIndent, builder3, isLiteral, ref end, ref isFirstLine);
					}
					if (num != -1)
					{
						builder.Append((object)builder2);
					}
					if (num == 1)
					{
						builder.Append((object)builder3);
					}
					ScalarStyle style = (isLiteral ? ScalarStyle.Literal : ScalarStyle.Folded);
					return new Scalar(builder.ToString(), style, start, end);
				}
				finally
				{
					((IDisposable)builderWrapper3/*cast due to constrained. prefix*//*cast due to constrained. prefix*/).Dispose();
				}
			}
			finally
			{
				((IDisposable)builderWrapper2/*cast due to constrained. prefix*//*cast due to constrained. prefix*/).Dispose();
			}
		}
		finally
		{
			((IDisposable)builderWrapper/*cast due to constrained. prefix*//*cast due to constrained. prefix*/).Dispose();
		}
	}

	private int ScanBlockScalarBreaks(int currentIndent, StringBuilder breaks, bool isLiteral, ref Mark end, ref bool? isFirstLine)
	{
		int num = 0;
		int num2 = -1;
		end = cursor.Mark();
		while (true)
		{
			if ((currentIndent == 0 || cursor.LineOffset < currentIndent) && analyzer.IsSpace())
			{
				Skip();
				continue;
			}
			if (cursor.LineOffset > num)
			{
				num = cursor.LineOffset;
			}
			if (!analyzer.IsBreak())
			{
				break;
			}
			if (isFirstLine == true)
			{
				isFirstLine = false;
				num2 = cursor.LineOffset;
			}
			breaks.Append(ReadLine());
			end = cursor.Mark();
		}
		if (isLiteral && isFirstLine == true)
		{
			int num3 = cursor.LineOffset;
			int num4 = 0;
			while (!analyzer.IsBreak(num4) && analyzer.IsSpace(num4))
			{
				num4++;
				num3++;
			}
			if (analyzer.IsBreak(num4) && num3 > cursor.LineOffset)
			{
				isFirstLine = false;
				num2 = num3;
			}
		}
		if (isLiteral && num2 > 1 && currentIndent < num2 - 1)
		{
			throw new SemanticErrorException(in end, cursor.Mark(), "While scanning a literal block scalar, found extra spaces in first line.");
		}
		if (!isLiteral && num > cursor.LineOffset && num2 > -1)
		{
			throw new SemanticErrorException(in end, cursor.Mark(), "While scanning a literal block scalar, found more spaces in lines above first content line.");
		}
		if (currentIndent == 0 && (cursor.LineOffset > 0 || indent > -1))
		{
			currentIndent = Math.Max(num, Math.Max(indent + 1, 1));
		}
		return currentIndent;
	}

	private void FetchQuotedScalar(bool isSingleQuoted)
	{
		SaveSimpleKey();
		simpleKeyAllowed = false;
		flowScalarFetched = flowLevel > 0;
		tokens.Enqueue(ScanFlowScalar(isSingleQuoted));
		if (!isSingleQuoted && analyzer.Check('#'))
		{
			Mark mark = cursor.Mark();
			tokens.Enqueue(new Error("While scanning a flow sequence end, found invalid comment after double-quoted scalar.", mark, mark));
		}
	}

	private Token ScanFlowScalar(bool isSingleQuoted)
	{
		Mark start = cursor.Mark();
		Skip();
		StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
		try
		{
			StringBuilder builder = builderWrapper.Builder;
			StringBuilderPool.BuilderWrapper builderWrapper2 = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder2 = builderWrapper2.Builder;
				StringBuilderPool.BuilderWrapper builderWrapper3 = StringBuilderPool.Rent();
				try
				{
					StringBuilder builder3 = builderWrapper3.Builder;
					StringBuilderPool.BuilderWrapper builderWrapper4 = StringBuilderPool.Rent();
					try
					{
						StringBuilder builder4 = builderWrapper4.Builder;
						bool flag = false;
						while (true)
						{
							if (IsDocumentIndicator())
							{
								throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a quoted scalar, found unexpected document indicator.");
							}
							if (analyzer.IsZero())
							{
								throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a quoted scalar, found unexpected end of stream.");
							}
							if (flag && !isSingleQuoted && indent >= cursor.LineOffset)
							{
								throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a multi-line double-quoted scalar, found wrong indentation.");
							}
							flag = false;
							while (!analyzer.IsWhiteBreakOrZero())
							{
								if (isSingleQuoted && analyzer.Check('\'') && analyzer.Check('\'', 1))
								{
									builder.Append('\'');
									Skip();
									Skip();
									continue;
								}
								if (analyzer.Check(isSingleQuoted ? '\'' : '"'))
								{
									break;
								}
								if (!isSingleQuoted && analyzer.Check('\\') && analyzer.IsBreak(1))
								{
									Skip();
									SkipLine();
									flag = true;
									break;
								}
								if (!isSingleQuoted && analyzer.Check('\\'))
								{
									int num = 0;
									char c = analyzer.Peek(1);
									switch (c)
									{
									case 'x':
										num = 2;
										break;
									case 'u':
										num = 4;
										break;
									case 'U':
										num = 8;
										break;
									default:
									{
										if (SimpleEscapeCodes.TryGetValue(c, out var value))
										{
											builder.Append(value);
											break;
										}
										throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a quoted scalar, found unknown escape character.");
									}
									}
									Skip();
									Skip();
									if (num <= 0)
									{
										continue;
									}
									int num2 = 0;
									for (int i = 0; i < num; i++)
									{
										if (!analyzer.IsHex(i))
										{
											throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a quoted scalar, did not find expected hexadecimal number.");
										}
										num2 = (num2 << 4) + analyzer.AsHex(i);
									}
									if ((num2 >= 55296 && num2 <= 57343) || num2 > 1114111)
									{
										throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a quoted scalar, found invalid Unicode character escape code.");
									}
									builder.Append(char.ConvertFromUtf32(num2));
									for (int j = 0; j < num; j++)
									{
										Skip();
									}
								}
								else
								{
									builder.Append(ReadCurrentCharacter());
								}
							}
							if (analyzer.Check(isSingleQuoted ? '\'' : '"'))
							{
								break;
							}
							while (analyzer.IsWhite() || analyzer.IsBreak())
							{
								if (analyzer.IsWhite())
								{
									if (!flag)
									{
										builder2.Append(ReadCurrentCharacter());
									}
									else
									{
										Skip();
									}
								}
								else if (!flag)
								{
									builder2.Length = 0;
									builder3.Append(ReadLine());
									flag = true;
								}
								else
								{
									builder4.Append(ReadLine());
								}
							}
							if (flag)
							{
								if (StartsWith(builder3, '\n'))
								{
									if (builder4.Length == 0)
									{
										builder.Append(' ');
									}
									else
									{
										builder.Append(builder4.ToString());
									}
								}
								else
								{
									builder.Append(builder3.ToString());
									builder.Append(builder4.ToString());
								}
								builder3.Length = 0;
								builder4.Length = 0;
							}
							else
							{
								builder.Append(builder2.ToString());
								builder2.Length = 0;
							}
						}
						Skip();
						return new Scalar(builder.ToString(), isSingleQuoted ? ScalarStyle.SingleQuoted : ScalarStyle.DoubleQuoted, start, cursor.Mark());
					}
					finally
					{
						((IDisposable)builderWrapper4/*cast due to constrained. prefix*//*cast due to constrained. prefix*/).Dispose();
					}
				}
				finally
				{
					((IDisposable)builderWrapper3/*cast due to constrained. prefix*//*cast due to constrained. prefix*/).Dispose();
				}
			}
			finally
			{
				((IDisposable)builderWrapper2/*cast due to constrained. prefix*//*cast due to constrained. prefix*/).Dispose();
			}
		}
		finally
		{
			((IDisposable)builderWrapper/*cast due to constrained. prefix*//*cast due to constrained. prefix*/).Dispose();
		}
	}

	private void FetchPlainScalar()
	{
		SaveSimpleKey();
		simpleKeyAllowed = false;
		bool isMultiline = false;
		Scalar item = (lastScalar = ScanPlainScalar(ref isMultiline));
		if (isMultiline && analyzer.Check(':') && flowLevel == 0 && indent < cursor.LineOffset)
		{
			tokens.Enqueue(new Error("While scanning a multiline plain scalar, found invalid mapping.", cursor.Mark(), cursor.Mark()));
		}
		tokens.Enqueue(item);
	}

	private Scalar ScanPlainScalar(ref bool isMultiline)
	{
		StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
		try
		{
			StringBuilder builder = builderWrapper.Builder;
			StringBuilderPool.BuilderWrapper builderWrapper2 = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder2 = builderWrapper2.Builder;
				StringBuilderPool.BuilderWrapper builderWrapper3 = StringBuilderPool.Rent();
				try
				{
					StringBuilder builder3 = builderWrapper3.Builder;
					StringBuilderPool.BuilderWrapper builderWrapper4 = StringBuilderPool.Rent();
					try
					{
						StringBuilder builder4 = builderWrapper4.Builder;
						bool flag = false;
						int num = indent + 1;
						Mark start = cursor.Mark();
						Mark end = start;
						SimpleKey simpleKey = simpleKeys.Peek();
						while (!IsDocumentIndicator())
						{
							if (analyzer.Check('#'))
							{
								if (indent < 0 && flowLevel == 0)
								{
									plainScalarFollowedByComment = true;
								}
								break;
							}
							bool flag2 = analyzer.Check('*') && (!simpleKey.IsPossible || !simpleKey.IsRequired);
							while (!analyzer.IsWhiteBreakOrZero())
							{
								if ((analyzer.Check(':') && !flag2 && (analyzer.IsWhiteBreakOrZero(1) || (flowLevel > 0 && analyzer.Check(',', 1)))) || (flowLevel > 0 && analyzer.Check(",[]{}")))
								{
									if (flowLevel == 0 && !simpleKey.IsPossible)
									{
										tokens.Enqueue(new Error("While scanning a plain scalar value, found invalid mapping.", cursor.Mark(), cursor.Mark()));
									}
									break;
								}
								if (flag || builder2.Length > 0)
								{
									if (flag)
									{
										if (StartsWith(builder3, '\n'))
										{
											if (builder4.Length == 0)
											{
												builder.Append(' ');
											}
											else
											{
												builder.Append((object)builder4);
											}
										}
										else
										{
											builder.Append((object)builder3);
											builder.Append((object)builder4);
										}
										builder3.Length = 0;
										builder4.Length = 0;
										flag = false;
									}
									else
									{
										builder.Append((object)builder2);
										builder2.Length = 0;
									}
								}
								if (flowLevel > 0 && cursor.LineOffset < num)
								{
									throw new Exception();
								}
								builder.Append(ReadCurrentCharacter());
								end = cursor.Mark();
							}
							if (!analyzer.IsWhite() && !analyzer.IsBreak())
							{
								break;
							}
							while (analyzer.IsWhite() || analyzer.IsBreak())
							{
								if (analyzer.IsWhite())
								{
									if (flag && cursor.LineOffset < num && analyzer.IsTab())
									{
										throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a plain scalar, found a tab character that violate indentation.");
									}
									if (!flag)
									{
										builder2.Append(ReadCurrentCharacter());
									}
									else
									{
										Skip();
									}
								}
								else
								{
									isMultiline = true;
									if (!flag)
									{
										builder2.Length = 0;
										builder3.Append(ReadLine());
										flag = true;
									}
									else
									{
										builder4.Append(ReadLine());
									}
								}
							}
							if (flowLevel == 0 && cursor.LineOffset < num)
							{
								break;
							}
						}
						if (flag)
						{
							simpleKeyAllowed = true;
						}
						return new Scalar(builder.ToString(), ScalarStyle.Plain, start, end);
					}
					finally
					{
						((IDisposable)builderWrapper4/*cast due to constrained. prefix*//*cast due to constrained. prefix*/).Dispose();
					}
				}
				finally
				{
					((IDisposable)builderWrapper3/*cast due to constrained. prefix*//*cast due to constrained. prefix*/).Dispose();
				}
			}
			finally
			{
				((IDisposable)builderWrapper2/*cast due to constrained. prefix*//*cast due to constrained. prefix*/).Dispose();
			}
		}
		finally
		{
			((IDisposable)builderWrapper/*cast due to constrained. prefix*//*cast due to constrained. prefix*/).Dispose();
		}
	}

	private void RemoveSimpleKey()
	{
		SimpleKey simpleKey = simpleKeys.Peek();
		if (simpleKey.IsPossible && simpleKey.IsRequired)
		{
			throw new SyntaxErrorException(simpleKey.Mark, simpleKey.Mark, "While scanning a simple key, could not find expected ':'.");
		}
		simpleKey.MarkAsImpossible();
	}

	private string ScanDirectiveName(in Mark start)
	{
		StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
		try
		{
			StringBuilder builder = builderWrapper.Builder;
			while (analyzer.IsAlphaNumericDashOrUnderscore())
			{
				builder.Append(ReadCurrentCharacter());
			}
			if (builder.Length == 0)
			{
				throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a directive, could not find expected directive name.");
			}
			if (analyzer.EndOfInput)
			{
				throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a directive, found unexpected end of stream.");
			}
			if (!analyzer.IsWhiteBreakOrZero())
			{
				throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a directive, found unexpected non-alphabetical character.");
			}
			return builder.ToString();
		}
		finally
		{
			((IDisposable)builderWrapper/*cast due to constrained. prefix*//*cast due to constrained. prefix*/).Dispose();
		}
	}

	private void SkipWhitespaces()
	{
		while (analyzer.IsWhite())
		{
			Skip();
		}
	}

	private Token ScanVersionDirectiveValue(in Mark start)
	{
		SkipWhitespaces();
		int major = ScanVersionDirectiveNumber(in start);
		if (!analyzer.Check('.'))
		{
			throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a %YAML directive, did not find expected digit or '.' character.");
		}
		Skip();
		int minor = ScanVersionDirectiveNumber(in start);
		return new VersionDirective(new Version(major, minor), start, start);
	}

	private Token ScanTagDirectiveValue(in Mark start)
	{
		SkipWhitespaces();
		string handle = ScanTagHandle(isDirective: true, start);
		if (!analyzer.IsWhite())
		{
			throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a %TAG directive, did not find expected whitespace.");
		}
		SkipWhitespaces();
		string prefix = ScanTagUri(null, start);
		if (!analyzer.IsWhiteBreakOrZero())
		{
			throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a %TAG directive, did not find expected whitespace or line break.");
		}
		return new TagDirective(handle, prefix, start, start);
	}

	private string ScanTagUri(string? head, Mark start)
	{
		StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
		try
		{
			StringBuilder builder = builderWrapper.Builder;
			if (head != null && head.Length > 1)
			{
				builder.Append(head.Substring(1));
			}
			while (analyzer.IsAlphaNumericDashOrUnderscore() || analyzer.Check(";/?:@&=+$.!~*'()[]%") || (analyzer.Check(',') && !analyzer.IsBreak(1)))
			{
				if (analyzer.Check('%'))
				{
					builder.Append(ScanUriEscapes(in start));
				}
				else if (analyzer.Check('+'))
				{
					builder.Append(' ');
					Skip();
				}
				else
				{
					builder.Append(ReadCurrentCharacter());
				}
			}
			if (builder.Length == 0)
			{
				return string.Empty;
			}
			string text = builder.ToString();
			if (text.EndsWith(","))
			{
				throw new SyntaxErrorException(cursor.Mark(), cursor.Mark(), "Unexpected comma at end of tag");
			}
			return text;
		}
		finally
		{
			((IDisposable)builderWrapper/*cast due to constrained. prefix*//*cast due to constrained. prefix*/).Dispose();
		}
	}

	private string ScanUriEscapes(in Mark start)
	{
		byte[] array = EmptyBytes;
		int count = 0;
		int num = 0;
		do
		{
			if (!analyzer.Check('%') || !analyzer.IsHex(1) || !analyzer.IsHex(2))
			{
				throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a tag, did not find URI escaped octet.");
			}
			int num2 = (analyzer.AsHex(1) << 4) + analyzer.AsHex(2);
			if (num == 0)
			{
				num = (((num2 & 0x80) == 0) ? 1 : (((num2 & 0xE0) == 192) ? 2 : (((num2 & 0xF0) == 224) ? 3 : (((num2 & 0xF8) == 240) ? 4 : 0))));
				if (num == 0)
				{
					throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a tag, found an incorrect leading UTF-8 octet.");
				}
				array = new byte[num];
			}
			else if ((num2 & 0xC0) != 128)
			{
				throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a tag, found an incorrect trailing UTF-8 octet.");
			}
			array[count++] = (byte)num2;
			Skip();
			Skip();
			Skip();
		}
		while (--num > 0);
		string text = Encoding.UTF8.GetString(array, 0, count);
		if (text.Length == 0 || text.Length > 2)
		{
			throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a tag, found an incorrect UTF-8 sequence.");
		}
		return text;
	}

	private string ScanTagHandle(bool isDirective, Mark start)
	{
		if (!analyzer.Check('!'))
		{
			throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a tag, did not find expected '!'.");
		}
		StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
		try
		{
			StringBuilder builder = builderWrapper.Builder;
			builder.Append(ReadCurrentCharacter());
			while (analyzer.IsAlphaNumericDashOrUnderscore())
			{
				builder.Append(ReadCurrentCharacter());
			}
			if (analyzer.Check('!'))
			{
				builder.Append(ReadCurrentCharacter());
			}
			else if (isDirective && (builder.Length != 1 || builder[0] != '!'))
			{
				throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a tag directive, did not find expected '!'.");
			}
			return builder.ToString();
		}
		finally
		{
			((IDisposable)builderWrapper/*cast due to constrained. prefix*//*cast due to constrained. prefix*/).Dispose();
		}
	}

	private int ScanVersionDirectiveNumber(in Mark start)
	{
		int num = 0;
		int num2 = 0;
		while (analyzer.IsDigit())
		{
			if (++num2 > 9)
			{
				throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a %YAML directive, found extremely long version number.");
			}
			num = num * 10 + analyzer.AsDigit();
			Skip();
		}
		if (num2 == 0)
		{
			throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a %YAML directive, did not find expected version number.");
		}
		return num;
	}

	private void SaveSimpleKey()
	{
		bool isRequired = flowLevel == 0 && indent == cursor.LineOffset;
		if (simpleKeyAllowed)
		{
			SimpleKey item = new SimpleKey(isRequired, tokensParsed + tokens.Count, cursor);
			RemoveSimpleKey();
			simpleKeys.Pop();
			simpleKeys.Push(item);
		}
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.SemanticErrorException ----
namespace YamlDotNet.Core
{
internal class SemanticErrorException : YamlException
{
	public SemanticErrorException(string message)
		: base(message)
	{
	}

	public SemanticErrorException(in Mark start, in Mark end, string message)
		: base(in start, in end, message)
	{
	}

	public SemanticErrorException(string message, Exception inner)
		: base(message, inner)
	{
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.SimpleKey ----
namespace YamlDotNet.Core
{
internal sealed class SimpleKey
{
	private readonly Cursor cursor;

	public bool IsPossible { get; private set; }

	public bool IsRequired { get; }

	public int TokenNumber { get; }

	public int Index => cursor.Index;

	public int Line => cursor.Line;

	public int LineOffset => cursor.LineOffset;

	public Mark Mark => cursor.Mark();

	public void MarkAsImpossible()
	{
		IsPossible = false;
	}

	public SimpleKey()
	{
		cursor = new Cursor();
	}

	public SimpleKey(bool isRequired, int tokenNumber, Cursor cursor)
	{
		IsPossible = true;
		IsRequired = isRequired;
		TokenNumber = tokenNumber;
		this.cursor = new Cursor(cursor);
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.StringLookAheadBuffer ----
namespace YamlDotNet.Core
{
internal sealed class StringLookAheadBuffer : ILookAheadBuffer
{
	private readonly string value;

	public int Position { get; private set; }

	public int Length => value.Length;

	public bool EndOfInput => IsOutside(Position);

	public StringLookAheadBuffer(string value)
	{
		this.value = value;
	}

	public char Peek(int offset)
	{
		int index = Position + offset;
		if (!IsOutside(index))
		{
			return value[index];
		}
		return '\0';
	}

	private bool IsOutside(int index)
	{
		return index >= value.Length;
	}

	public void Skip(int length)
	{
		if (length < 0)
		{
			throw new ArgumentOutOfRangeException("length", "The length must be positive.");
		}
		Position += length;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.SyntaxErrorException ----
namespace YamlDotNet.Core
{
internal sealed class SyntaxErrorException : YamlException
{
	public SyntaxErrorException(string message)
		: base(message)
	{
	}

	public SyntaxErrorException(in Mark start, in Mark end, string message)
		: base(in start, in end, message)
	{
	}

	public SyntaxErrorException(string message, Exception inner)
		: base(message, inner)
	{
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.TagDirectiveCollection ----
namespace YamlDotNet.Core
{
internal sealed class TagDirectiveCollection : KeyedCollection<string, TagDirective>
{
	public TagDirectiveCollection()
	{
	}

	public TagDirectiveCollection(IEnumerable<TagDirective> tagDirectives)
	{
		foreach (TagDirective tagDirective in tagDirectives)
		{
			Add(tagDirective);
		}
	}

	protected override string GetKeyForItem(TagDirective item)
	{
		return item.Handle;
	}

	public new bool Contains(TagDirective directive)
	{
		return Contains(GetKeyForItem(directive));
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.TagName ----
namespace YamlDotNet.Core
{
internal readonly struct TagName : IEquatable<TagName>
{
	public static readonly TagName Empty;

	private readonly string? value;

	public string Value => value ?? throw new InvalidOperationException("Cannot read the Value of a non-specific tag");

	public bool IsEmpty => value == null;

	public bool IsNonSpecific
	{
		get
		{
			if (!IsEmpty)
			{
				if (!(value == "!"))
				{
					return value == "?";
				}
				return true;
			}
			return false;
		}
	}

	public bool IsLocal
	{
		get
		{
			if (!IsEmpty)
			{
				return Value[0] == '!';
			}
			return false;
		}
	}

	public bool IsGlobal
	{
		get
		{
			if (!IsEmpty)
			{
				return !IsLocal;
			}
			return false;
		}
	}

	public TagName(string value)
	{
		this.value = value ?? throw new ArgumentNullException("value");
		if (value.Length == 0)
		{
			throw new ArgumentException("Tag value must not be empty.", "value");
		}
		if (IsGlobal && !Uri.IsWellFormedUriString(value, UriKind.RelativeOrAbsolute))
		{
			throw new ArgumentException("Global tags must be valid URIs.", "value");
		}
	}

	public override string ToString()
	{
		return value ?? "?";
	}

	public bool Equals(TagName other)
	{
		return object.Equals(value, other.value);
	}

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

	public override int GetHashCode()
	{
		return value?.GetHashCode() ?? 0;
	}

	public static bool operator ==(TagName left, TagName right)
	{
		return left.Equals(right);
	}

	public static bool operator !=(TagName left, TagName right)
	{
		return !(left == right);
	}

	public static bool operator ==(TagName left, string right)
	{
		return object.Equals(left.value, right);
	}

	public static bool operator !=(TagName left, string right)
	{
		return !(left == right);
	}

	public static implicit operator TagName(string? value)
	{
		if (value != null)
		{
			return new TagName(value);
		}
		return Empty;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Version ----
namespace YamlDotNet.Core
{
internal sealed class Version
{
	public int Major { get; }

	public int Minor { get; }

	public Version(int major, int minor)
	{
		if (major < 0)
		{
			throw new ArgumentOutOfRangeException("major", $"{major} should be >= 0");
		}
		Major = major;
		if (minor < 0)
		{
			throw new ArgumentOutOfRangeException("minor", $"{minor} should be >= 0");
		}
		Minor = minor;
	}

	public override bool Equals(object? obj)
	{
		if (obj is Version version && Major == version.Major)
		{
			return Minor == version.Minor;
		}
		return false;
	}

	public override int GetHashCode()
	{
		return HashCode.CombineHashCodes(Major.GetHashCode(), Minor.GetHashCode());
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.YamlException ----
namespace YamlDotNet.Core
{
internal class YamlException : Exception
{
	public Mark Start { get; }

	public Mark End { get; }

	public YamlException(string message)
		: this(in Mark.Empty, in Mark.Empty, message)
	{
	}

	public YamlException(in Mark start, in Mark end, string message)
		: this(in start, in end, message, null)
	{
	}

	public YamlException(in Mark start, in Mark end, string message, Exception? innerException)
		: base(message, innerException)
	{
		Start = start;
		End = end;
	}

	public YamlException(string message, Exception inner)
		: this(in Mark.Empty, in Mark.Empty, message, inner)
	{
	}

	public override string ToString()
	{
		return $"({Start}) - ({End}): {Message}";
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Tokens.Anchor ----
namespace YamlDotNet.Core.Tokens
{
internal class Anchor : Token
{
	public AnchorName Value { get; }

	public Anchor(AnchorName value)
		: this(value, Mark.Empty, Mark.Empty)
	{
	}

	public Anchor(AnchorName value, Mark start, Mark end)
		: base(in start, in end)
	{
		if (value.IsEmpty)
		{
			throw new ArgumentNullException("value");
		}
		Value = value;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Tokens.AnchorAlias ----
namespace YamlDotNet.Core.Tokens
{
internal sealed class AnchorAlias : Token
{
	public AnchorName Value { get; }

	public AnchorAlias(AnchorName value)
		: this(value, Mark.Empty, Mark.Empty)
	{
	}

	public AnchorAlias(AnchorName value, Mark start, Mark end)
		: base(in start, in end)
	{
		if (value.IsEmpty)
		{
			throw new ArgumentNullException("value");
		}
		Value = value;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Tokens.BlockEnd ----
namespace YamlDotNet.Core.Tokens
{
internal sealed class BlockEnd : Token
{
	public BlockEnd()
		: this(in Mark.Empty, in Mark.Empty)
	{
	}

	public BlockEnd(in Mark start, in Mark end)
		: base(in start, in end)
	{
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Tokens.BlockEntry ----
namespace YamlDotNet.Core.Tokens
{
internal sealed class BlockEntry : Token
{
	public BlockEntry()
		: this(in Mark.Empty, in Mark.Empty)
	{
	}

	public BlockEntry(in Mark start, in Mark end)
		: base(in start, in end)
	{
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Tokens.BlockMappingStart ----
namespace YamlDotNet.Core.Tokens
{
internal sealed class BlockMappingStart : Token
{
	public BlockMappingStart()
		: this(in Mark.Empty, in Mark.Empty)
	{
	}

	public BlockMappingStart(in Mark start, in Mark end)
		: base(in start, in end)
	{
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Tokens.BlockSequenceStart ----
namespace YamlDotNet.Core.Tokens
{
internal sealed class BlockSequenceStart : Token
{
	public BlockSequenceStart()
		: this(in Mark.Empty, in Mark.Empty)
	{
	}

	public BlockSequenceStart(in Mark start, in Mark end)
		: base(in start, in end)
	{
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Tokens.Comment ----
namespace YamlDotNet.Core.Tokens
{
internal sealed class Comment : Token
{
	public string Value { get; }

	public bool IsInline { get; }

	public Comment(string value, bool isInline)
		: this(value, isInline, Mark.Empty, Mark.Empty)
	{
	}

	public Comment(string value, bool isInline, Mark start, Mark end)
		: base(in start, in end)
	{
		Value = value ?? throw new ArgumentNullException("value");
		IsInline = isInline;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Tokens.DocumentEnd ----
namespace YamlDotNet.Core.Tokens
{
internal sealed class DocumentEnd : Token
{
	public DocumentEnd()
		: this(in Mark.Empty, in Mark.Empty)
	{
	}

	public DocumentEnd(in Mark start, in Mark end)
		: base(in start, in end)
	{
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Tokens.DocumentStart ----
namespace YamlDotNet.Core.Tokens
{
internal sealed class DocumentStart : Token
{
	public DocumentStart()
		: this(in Mark.Empty, in Mark.Empty)
	{
	}

	public DocumentStart(in Mark start, in Mark end)
		: base(in start, in end)
	{
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Tokens.Error ----
namespace YamlDotNet.Core.Tokens
{
internal class Error : Token
{
	public string Value { get; }

	public Error(string value, Mark start, Mark end)
		: base(in start, in end)
	{
		Value = value;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Tokens.FlowEntry ----
namespace YamlDotNet.Core.Tokens
{
internal sealed class FlowEntry : Token
{
	public FlowEntry()
		: this(in Mark.Empty, in Mark.Empty)
	{
	}

	public FlowEntry(in Mark start, in Mark end)
		: base(in start, in end)
	{
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Tokens.FlowMappingEnd ----
namespace YamlDotNet.Core.Tokens
{
internal sealed class FlowMappingEnd : Token
{
	public FlowMappingEnd()
		: this(in Mark.Empty, in Mark.Empty)
	{
	}

	public FlowMappingEnd(in Mark start, in Mark end)
		: base(in start, in end)
	{
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Tokens.FlowMappingStart ----
namespace YamlDotNet.Core.Tokens
{
internal sealed class FlowMappingStart : Token
{
	public FlowMappingStart()
		: this(in Mark.Empty, in Mark.Empty)
	{
	}

	public FlowMappingStart(in Mark start, in Mark end)
		: base(in start, in end)
	{
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Tokens.FlowSequenceEnd ----
namespace YamlDotNet.Core.Tokens
{
internal sealed class FlowSequenceEnd : Token
{
	public FlowSequenceEnd()
		: this(in Mark.Empty, in Mark.Empty)
	{
	}

	public FlowSequenceEnd(in Mark start, in Mark end)
		: base(in start, in end)
	{
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Tokens.FlowSequenceStart ----
namespace YamlDotNet.Core.Tokens
{
internal sealed class FlowSequenceStart : Token
{
	public FlowSequenceStart()
		: this(in Mark.Empty, in Mark.Empty)
	{
	}

	public FlowSequenceStart(in Mark start, in Mark end)
		: base(in start, in end)
	{
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Tokens.Key ----
namespace YamlDotNet.Core.Tokens
{
internal sealed class Key : Token
{
	public Key()
		: this(in Mark.Empty, in Mark.Empty)
	{
	}

	public Key(in Mark start, in Mark end)
		: base(in start, in end)
	{
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Tokens.Scalar ----
namespace YamlDotNet.Core.Tokens
{
internal sealed class Scalar : Token
{
	public bool IsKey { get; set; }

	public string Value { get; }

	public ScalarStyle Style { get; }

	public Scalar(string value)
		: this(value, ScalarStyle.Any)
	{
	}

	public Scalar(string value, ScalarStyle style)
		: this(value, style, Mark.Empty, Mark.Empty)
	{
	}

	public Scalar(string value, ScalarStyle style, Mark start, Mark end)
		: base(in start, in end)
	{
		Value = value ?? throw new ArgumentNullException("value");
		Style = style;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Tokens.StreamEnd ----
namespace YamlDotNet.Core.Tokens
{
internal sealed class StreamEnd : Token
{
	public StreamEnd()
		: this(in Mark.Empty, in Mark.Empty)
	{
	}

	public StreamEnd(in Mark start, in Mark end)
		: base(in start, in end)
	{
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Tokens.StreamStart ----
namespace YamlDotNet.Core.Tokens
{
internal sealed class StreamStart : Token
{
	public StreamStart()
		: this(in Mark.Empty, in Mark.Empty)
	{
	}

	public StreamStart(in Mark start, in Mark end)
		: base(in start, in end)
	{
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Tokens.Tag ----
namespace YamlDotNet.Core.Tokens
{
internal sealed class Tag : Token
{
	public string Handle { get; }

	public string Suffix { get; }

	public Tag(string handle, string suffix)
		: this(handle, suffix, Mark.Empty, Mark.Empty)
	{
	}

	public Tag(string handle, string suffix, Mark start, Mark end)
		: base(in start, in end)
	{
		Handle = handle ?? throw new ArgumentNullException("handle");
		Suffix = suffix ?? throw new ArgumentNullException("suffix");
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Tokens.TagDirective ----
namespace YamlDotNet.Core.Tokens
{
internal class TagDirective : Token
{
	private static readonly Regex TagHandlePattern = new Regex("^!([0-9A-Za-z_\\-]*!)?$", RegexOptions.Compiled);

	public string Handle { get; }

	public string Prefix { get; }

	public TagDirective(string handle, string prefix)
		: this(handle, prefix, Mark.Empty, Mark.Empty)
	{
	}

	public TagDirective(string handle, string prefix, Mark start, Mark end)
		: base(in start, in end)
	{
		if (string.IsNullOrEmpty(handle))
		{
			throw new ArgumentNullException("handle", "Tag handle must not be empty.");
		}
		if (!TagHandlePattern.IsMatch(handle))
		{
			throw new ArgumentException("Tag handle must start and end with '!' and contain alphanumerical characters only.", "handle");
		}
		Handle = handle;
		if (string.IsNullOrEmpty(prefix))
		{
			throw new ArgumentNullException("prefix", "Tag prefix must not be empty.");
		}
		Prefix = prefix;
	}

	public override bool Equals(object? obj)
	{
		if (obj is TagDirective tagDirective && Handle.Equals(tagDirective.Handle))
		{
			return Prefix.Equals(tagDirective.Prefix);
		}
		return false;
	}

	public override int GetHashCode()
	{
		return Handle.GetHashCode() ^ Prefix.GetHashCode();
	}

	public override string ToString()
	{
		return Handle + " => " + Prefix;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Tokens.Token ----
namespace YamlDotNet.Core.Tokens
{
internal abstract class Token
{
	public Mark Start { get; }

	public Mark End { get; }

	protected Token(in Mark start, in Mark end)
	{
		Start = start;
		End = end;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Tokens.Value ----
namespace YamlDotNet.Core.Tokens
{
internal sealed class Value : Token
{
	public Value()
		: this(in Mark.Empty, in Mark.Empty)
	{
	}

	public Value(in Mark start, in Mark end)
		: base(in start, in end)
	{
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Tokens.VersionDirective ----
namespace YamlDotNet.Core.Tokens
{
internal sealed class VersionDirective : Token
{
	public Version Version { get; }

	public VersionDirective(Version version)
		: this(version, Mark.Empty, Mark.Empty)
	{
	}

	public VersionDirective(Version version, Mark start, Mark end)
		: base(in start, in end)
	{
		Version = version;
	}

	public override bool Equals(object? obj)
	{
		if (obj is VersionDirective versionDirective)
		{
			return Version.Equals(versionDirective.Version);
		}
		return false;
	}

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

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Events.AnchorAlias ----
namespace YamlDotNet.Core.Events
{
internal sealed class AnchorAlias : ParsingEvent
{
	internal override EventType Type => EventType.Alias;

	public AnchorName Value { get; }

	public AnchorAlias(AnchorName value, Mark start, Mark end)
		: base(in start, in end)
	{
		if (value.IsEmpty)
		{
			throw new YamlException(in start, in end, "Anchor value must not be empty.");
		}
		Value = value;
	}

	public AnchorAlias(AnchorName value)
		: this(value, Mark.Empty, Mark.Empty)
	{
	}

	public override string ToString()
	{
		return $"Alias [value = {Value}]";
	}

	public override void Accept(IParsingEventVisitor visitor)
	{
		visitor.Visit(this);
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Events.Comment ----
namespace YamlDotNet.Core.Events
{
internal sealed class Comment : ParsingEvent
{
	public string Value { get; }

	public bool IsInline { get; }

	internal override EventType Type => EventType.Comment;

	public Comment(string value, bool isInline)
		: this(value, isInline, Mark.Empty, Mark.Empty)
	{
	}

	public Comment(string value, bool isInline, Mark start, Mark end)
		: base(in start, in end)
	{
		Value = value;
		IsInline = isInline;
	}

	public override void Accept(IParsingEventVisitor visitor)
	{
		visitor.Visit(this);
	}

	public override string ToString()
	{
		return (IsInline ? "Inline" : "Block") + " Comment [" + Value + "]";
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Events.DocumentEnd ----
namespace YamlDotNet.Core.Events
{
internal sealed class DocumentEnd : ParsingEvent
{
	public override int NestingIncrease => -1;

	internal override EventType Type => EventType.DocumentEnd;

	public bool IsImplicit { get; }

	public DocumentEnd(bool isImplicit, Mark start, Mark end)
		: base(in start, in end)
	{
		IsImplicit = isImplicit;
	}

	public DocumentEnd(bool isImplicit)
		: this(isImplicit, Mark.Empty, Mark.Empty)
	{
	}

	public override string ToString()
	{
		return $"Document end [isImplicit = {IsImplicit}]";
	}

	public override void Accept(IParsingEventVisitor visitor)
	{
		visitor.Visit(this);
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Events.DocumentStart ----
namespace YamlDotNet.Core.Events
{
internal sealed class DocumentStart : ParsingEvent
{
	public override int NestingIncrease => 1;

	internal override EventType Type => EventType.DocumentStart;

	public TagDirectiveCollection? Tags { get; }

	public VersionDirective? Version { get; }

	public bool IsImplicit { get; }

	public DocumentStart(VersionDirective? version, TagDirectiveCollection? tags, bool isImplicit, Mark start, Mark end)
		: base(in start, in end)
	{
		Version = version;
		Tags = tags;
		IsImplicit = isImplicit;
	}

	public DocumentStart(VersionDirective? version, TagDirectiveCollection? tags, bool isImplicit)
		: this(version, tags, isImplicit, Mark.Empty, Mark.Empty)
	{
	}

	public DocumentStart(in Mark start, in Mark end)
		: this(null, null, isImplicit: true, start, end)
	{
	}

	public DocumentStart()
		: this(null, null, isImplicit: true, Mark.Empty, Mark.Empty)
	{
	}

	public override string ToString()
	{
		return $"Document start [isImplicit = {IsImplicit}]";
	}

	public override void Accept(IParsingEventVisitor visitor)
	{
		visitor.Visit(this);
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Events.EventType ----
namespace YamlDotNet.Core.Events
{
internal enum EventType
{
	None,
	StreamStart,
	StreamEnd,
	DocumentStart,
	DocumentEnd,
	Alias,
	Scalar,
	SequenceStart,
	SequenceEnd,
	MappingStart,
	MappingEnd,
	Comment
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Events.IParsingEventVisitor ----
namespace YamlDotNet.Core.Events
{
internal interface IParsingEventVisitor
{
	void Visit(AnchorAlias e);

	void Visit(StreamStart e);

	void Visit(StreamEnd e);

	void Visit(DocumentStart e);

	void Visit(DocumentEnd e);

	void Visit(Scalar e);

	void Visit(SequenceStart e);

	void Visit(SequenceEnd e);

	void Visit(MappingStart e);

	void Visit(MappingEnd e);

	void Visit(Comment e);
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Events.MappingEnd ----
namespace YamlDotNet.Core.Events
{
internal class MappingEnd : ParsingEvent
{
	public override int NestingIncrease => -1;

	internal override EventType Type => EventType.MappingEnd;

	public MappingEnd(in Mark start, in Mark end)
		: base(in start, in end)
	{
	}

	public MappingEnd()
		: this(in Mark.Empty, in Mark.Empty)
	{
	}

	public override string ToString()
	{
		return "Mapping end";
	}

	public override void Accept(IParsingEventVisitor visitor)
	{
		visitor.Visit(this);
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Events.MappingStart ----
namespace YamlDotNet.Core.Events
{
internal sealed class MappingStart : NodeEvent
{
	public override int NestingIncrease => 1;

	internal override EventType Type => EventType.MappingStart;

	public bool IsImplicit { get; }

	public override bool IsCanonical => !IsImplicit;

	public MappingStyle Style { get; }

	public MappingStart(AnchorName anchor, TagName tag, bool isImplicit, MappingStyle style, Mark start, Mark end)
		: base(anchor, tag, start, end)
	{
		IsImplicit = isImplicit;
		Style = style;
	}

	public MappingStart(AnchorName anchor, TagName tag, bool isImplicit, MappingStyle style)
		: this(anchor, tag, isImplicit, style, Mark.Empty, Mark.Empty)
	{
	}

	public MappingStart()
		: this(AnchorName.Empty, TagName.Empty, isImplicit: true, MappingStyle.Any, Mark.Empty, Mark.Empty)
	{
	}

	public override string ToString()
	{
		return $"Mapping start [anchor = {base.Anchor}, tag = {base.Tag}, isImplicit = {IsImplicit}, style = {Style}]";
	}

	public override void Accept(IParsingEventVisitor visitor)
	{
		visitor.Visit(this);
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Events.MappingStyle ----
namespace YamlDotNet.Core.Events
{
internal enum MappingStyle
{
	Any,
	Block,
	Flow
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Events.NodeEvent ----
namespace YamlDotNet.Core.Events
{
internal abstract class NodeEvent : ParsingEvent
{
	public AnchorName Anchor { get; }

	public TagName Tag { get; }

	public abstract bool IsCanonical { get; }

	protected NodeEvent(AnchorName anchor, TagName tag, Mark start, Mark end)
		: base(in start, in end)
	{
		Anchor = anchor;
		Tag = tag;
	}

	protected NodeEvent(AnchorName anchor, TagName tag)
		: this(anchor, tag, Mark.Empty, Mark.Empty)
	{
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Events.ParsingEvent ----
namespace YamlDotNet.Core.Events
{
internal abstract class ParsingEvent
{
	public virtual int NestingIncrease => 0;

	internal abstract EventType Type { get; }

	public Mark Start { get; }

	public Mark End { get; }

	public abstract void Accept(IParsingEventVisitor visitor);

	internal ParsingEvent(in Mark start, in Mark end)
	{
		Start = start;
		End = end;
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Events.Scalar ----
namespace YamlDotNet.Core.Events
{
internal sealed class Scalar : NodeEvent
{
	internal override EventType Type => EventType.Scalar;

	public string Value { get; }

	public ScalarStyle Style { get; }

	public bool IsPlainImplicit { get; }

	public bool IsQuotedImplicit { get; }

	public override bool IsCanonical
	{
		get
		{
			if (!IsPlainImplicit)
			{
				return !IsQuotedImplicit;
			}
			return false;
		}
	}

	public bool IsKey { get; }

	public Scalar(AnchorName anchor, TagName tag, string value, ScalarStyle style, bool isPlainImplicit, bool isQuotedImplicit, Mark start, Mark end, bool isKey = false)
		: base(anchor, tag, start, end)
	{
		Value = value;
		Style = style;
		IsPlainImplicit = isPlainImplicit;
		IsQuotedImplicit = isQuotedImplicit;
		IsKey = isKey;
	}

	public Scalar(AnchorName anchor, TagName tag, string value, ScalarStyle style, bool isPlainImplicit, bool isQuotedImplicit)
		: this(anchor, tag, value, style, isPlainImplicit, isQuotedImplicit, Mark.Empty, Mark.Empty)
	{
	}

	public Scalar(string value)
		: this(AnchorName.Empty, TagName.Empty, value, ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: true, Mark.Empty, Mark.Empty)
	{
	}

	public Scalar(TagName tag, string value)
		: this(AnchorName.Empty, tag, value, ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: true, Mark.Empty, Mark.Empty)
	{
	}

	public Scalar(AnchorName anchor, TagName tag, string value)
		: this(anchor, tag, value, ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: true, Mark.Empty, Mark.Empty)
	{
	}

	public override string ToString()
	{
		return $"Scalar [anchor = {base.Anchor}, tag = {base.Tag}, value = {Value}, style = {Style}, isPlainImplicit = {IsPlainImplicit}, isQuotedImplicit = {IsQuotedImplicit}]";
	}

	public override void Accept(IParsingEventVisitor visitor)
	{
		visitor.Visit(this);
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Events.SequenceEnd ----
namespace YamlDotNet.Core.Events
{
internal sealed class SequenceEnd : ParsingEvent
{
	public override int NestingIncrease => -1;

	internal override EventType Type => EventType.SequenceEnd;

	public SequenceEnd(in Mark start, in Mark end)
		: base(in start, in end)
	{
	}

	public SequenceEnd()
		: this(in Mark.Empty, in Mark.Empty)
	{
	}

	public override string ToString()
	{
		return "Sequence end";
	}

	public override void Accept(IParsingEventVisitor visitor)
	{
		visitor.Visit(this);
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Events.SequenceStart ----
namespace YamlDotNet.Core.Events
{
internal sealed class SequenceStart : NodeEvent
{
	public override int NestingIncrease => 1;

	internal override EventType Type => EventType.SequenceStart;

	public bool IsImplicit { get; }

	public override bool IsCanonical => !IsImplicit;

	public SequenceStyle Style { get; }

	public SequenceStart(AnchorName anchor, TagName tag, bool isImplicit, SequenceStyle style, Mark start, Mark end)
		: base(anchor, tag, start, end)
	{
		IsImplicit = isImplicit;
		Style = style;
	}

	public SequenceStart(AnchorName anchor, TagName tag, bool isImplicit, SequenceStyle style)
		: this(anchor, tag, isImplicit, style, Mark.Empty, Mark.Empty)
	{
	}

	public override string ToString()
	{
		return $"Sequence start [anchor = {base.Anchor}, tag = {base.Tag}, isImplicit = {IsImplicit}, style = {Style}]";
	}

	public override void Accept(IParsingEventVisitor visitor)
	{
		visitor.Visit(this);
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Events.SequenceStyle ----
namespace YamlDotNet.Core.Events
{
internal enum SequenceStyle
{
	Any,
	Block,
	Flow
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Events.StreamEnd ----
namespace YamlDotNet.Core.Events
{
internal sealed class StreamEnd : ParsingEvent
{
	public override int NestingIncrease => -1;

	internal override EventType Type => EventType.StreamEnd;

	public StreamEnd(in Mark start, in Mark end)
		: base(in start, in end)
	{
	}

	public StreamEnd()
		: this(in Mark.Empty, in Mark.Empty)
	{
	}

	public override string ToString()
	{
		return "Stream end";
	}

	public override void Accept(IParsingEventVisitor visitor)
	{
		visitor.Visit(this);
	}
}

}


// ---- MistrootTamer.dll :: YamlDotNet.Core.Events.StreamStart ----
namespace YamlDotNet.Core.Events
{
internal sealed class StreamStart : ParsingEvent
{
	public override int NestingIncrease => 1;

	internal override EventType Type => EventType.StreamStart;

	public StreamStart()
		: this(in Mark.Empty, in Mark.Empty)
	{
	}

	public StreamStart(in Mark start, in Mark end)
		: base(in start, in end)
	{
	}

	public override string ToString()
	{
		return "Stream start";
	}

	public override void Accept(IParsingEventVisitor visitor)
	{
		visitor.Visit(this);
	}
}

}


// ---- MistrootTamer.dll :: System.Collections.Generic.DeconstructionExtensions ----
namespace System.Collections.Generic
{
internal static class DeconstructionExtensions
{
	public static void Deconstruct<TKey, TValue>(this KeyValuePair<TKey, TValue> pair, out TKey key, out TValue value)
	{
		key = pair.Key;
		value = pair.Value;
	}
}

}