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

[assembly: AssemblyFileVersion("3.0.6")]
[assembly: Guid("4358610B-F3F4-4843-B7AF-98B7BC60DCDE")]
[assembly: ComVisible(false)]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: AssemblyProduct("Magic_Supremacy")]
[assembly: AssemblyCompany("Dreanegade")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyTitle("Magic_Supremacy")]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: CompilationRelaxations(8)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("3.0.6.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[<335460cb-33f0-4d8c-9458-c7990561a517>Embedded]
	internal sealed class <335460cb-33f0-4d8c-9458-c7990561a517>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[<335460cb-33f0-4d8c-9458-c7990561a517>Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class <5ea91132-7291-4072-bba1-fdb04647c6e6>NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public <5ea91132-7291-4072-bba1-fdb04647c6e6>NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public <5ea91132-7291-4072-bba1-fdb04647c6e6>NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	[CompilerGenerated]
	[<335460cb-33f0-4d8c-9458-c7990561a517>Embedded]
	internal sealed class <702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public <702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
public static class ExtraTooltip
{
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
	private static class DevLog
	{
		public const bool Enabled = false;
	}

	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
	public enum TooltipAttackSlot
	{
		Main,
		Secondary
	}

	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	private class TooltipLinkDef
	{
		public readonly string ItemPrefabName;

		public readonly TooltipAttackSlot AttackSlot;

		public readonly List<TooltipEntry> Entries;

		public TooltipLinkDef(string itemPrefabName, TooltipAttackSlot attackSlot, string statusEffectPrefabName)
		{
			ItemPrefabName = itemPrefabName;
			AttackSlot = attackSlot;
			Entries = new List<TooltipEntry>
			{
				new TooltipSELine(statusEffectPrefabName)
			};
		}

		public TooltipLinkDef(string itemPrefabName, TooltipAttackSlot attackSlot, params TooltipEntry[] entries)
		{
			ItemPrefabName = itemPrefabName;
			AttackSlot = attackSlot;
			Entries = new List<TooltipEntry>(entries);
		}
	}

	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
	private abstract class TooltipEntry
	{
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
		public abstract string Build(string itemPrefabName, int qualityLevel, float skillLevel);
	}

	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	private class TooltipSELine : TooltipEntry
	{
		private readonly string StatusEffectPrefabName;

		public TooltipSELine(string statusEffectPrefabName)
		{
			StatusEffectPrefabName = statusEffectPrefabName;
		}

		public override string Build(string itemPrefabName, int qualityLevel, float skillLevel)
		{
			StatusEffect val = FindStatusEffect(StatusEffectPrefabName);
			if ((Object)(object)val == (Object)null)
			{
				DLog("StatusEffect not found: " + StatusEffectPrefabName + " for item " + itemPrefabName + ".");
				return "";
			}
			string text = BuildVanillaStatusEffectTooltip(val, qualityLevel, skillLevel);
			if (string.IsNullOrEmpty(text))
			{
				DLog("Tooltip skipped for " + itemPrefabName + ": empty tooltip from " + StatusEffectPrefabName + ".");
				return "";
			}
			return text;
		}
	}

	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	private class TooltipTextLine : TooltipEntry
	{
		private readonly string TextKeyOrText;

		private readonly string Color;

		public TooltipTextLine(string textKeyOrText, string color = null)
		{
			TextKeyOrText = textKeyOrText;
			Color = color;
		}

		public override string Build(string itemPrefabName, int qualityLevel, float skillLevel)
		{
			return Colorize(Localize(TextKeyOrText), Color);
		}
	}

	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	private class TooltipInlineLine : TooltipEntry
	{
		private readonly List<TooltipInlinePart> Parts;

		public TooltipInlineLine(params TooltipInlinePart[] parts)
		{
			Parts = new List<TooltipInlinePart>(parts);
		}

		public override string Build(string itemPrefabName, int qualityLevel, float skillLevel)
		{
			StringBuilder stringBuilder = new StringBuilder();
			foreach (TooltipInlinePart part in Parts)
			{
				if (part != null)
				{
					stringBuilder.Append(part.Build());
				}
			}
			return stringBuilder.ToString();
		}
	}

	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	private class TooltipInlinePart
	{
		private readonly string TextKeyOrText;

		private readonly string Color;

		public TooltipInlinePart(string textKeyOrText, string color = null)
		{
			TextKeyOrText = textKeyOrText;
			Color = color;
		}

		public string Build()
		{
			return Colorize(Localize(TextKeyOrText), Color);
		}
	}

	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
	[HarmonyPatch(typeof(ItemData), "GetTooltip", new Type[]
	{
		typeof(ItemData),
		typeof(int),
		typeof(bool),
		typeof(float),
		typeof(int)
	})]
	private static class ItemData_GetTooltip_ExtraTooltipPatch
	{
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
		private static void Postfix(ItemData item, int qualityLevel, bool crafting, float worldLevel, int stackOverride, ref string __result)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (item == null || item.m_shared == null)
				{
					return;
				}
				string itemPrefabName = GetItemPrefabName(item);
				if (string.IsNullOrEmpty(itemPrefabName))
				{
					return;
				}
				List<TooltipLinkDef> defsForItem = GetDefsForItem(itemPrefabName);
				if (defsForItem.Count != 0)
				{
					float skillLevel = 0f;
					if ((Object)(object)Player.m_localPlayer != (Object)null)
					{
						skillLevel = ((Character)Player.m_localPlayer).GetSkillLevel(item.m_shared.m_skillType);
					}
					StringBuilder stringBuilder = new StringBuilder();
					AppendEntriesForSlot(stringBuilder, defsForItem, TooltipAttackSlot.Main, qualityLevel, skillLevel);
					AppendEntriesForSlot(stringBuilder, defsForItem, TooltipAttackSlot.Secondary, qualityLevel, skillLevel);
					if (stringBuilder.Length <= 0)
					{
						DLog("Tooltip skipped for " + itemPrefabName + ": no valid extra tooltip was generated.");
						return;
					}
					__result = __result + "\n\n" + stringBuilder.ToString().TrimEnd(Array.Empty<char>());
					DLog("Extra tooltip added for " + itemPrefabName + ".");
				}
			}
			catch (Exception arg)
			{
				DLog($"ERROR while adding extra tooltip: {arg}");
			}
		}
	}

	private const string MainAttackHeaderColor = "#FFC654";

	private const string SecondaryAttackHeaderColor = "#FFC654";

	private const string VanillaSENameColor = "orange";

	private const string HealValueColor = "#C8FF6A";

	private const string MainAttackKey = "$main_attack_DO";

	private const string SecondaryAttackKey = "$secondary_attack_DO";

	private static readonly List<TooltipLinkDef> Defs = new List<TooltipLinkDef>
	{
		new TooltipLinkDef("StaffTotemcallerTotemDO", TooltipAttackSlot.Main, "SE_TotemSlow_DO"),
		new TooltipLinkDef("StaffTotemcallerTotemDO", TooltipAttackSlot.Secondary, "SE_TotemBuff_DO"),
		new TooltipLinkDef("StaffTotemcallerBoomerangDO", TooltipAttackSlot.Secondary, "SE_TotemcallerOrbit_DO"),
		new TooltipLinkDef("StaffMushroomcallerMushroomDO", TooltipAttackSlot.Main, new TooltipTextLine("$aoe_trap_damage_DO"), new TooltipTextLine(" "), new TooltipSELine("SE_MushroomcallerSlow_DO")),
		new TooltipLinkDef("StaffMushroomcallerMushroomDO", TooltipAttackSlot.Secondary, new TooltipTextLine("$aoe_area_light_DO")),
		new TooltipLinkDef("StaffDeathcallerBlasterDO", TooltipAttackSlot.Secondary, "SE_DeathcallerDebuff_DO"),
		new TooltipLinkDef("BowFrostcallerIceDO", TooltipAttackSlot.Secondary, new TooltipTextLine("$aoe_trap_damage_DO"), new TooltipTextLine("$aoe_area_debuff_DO"), new TooltipTextLine(" "), new TooltipSELine("SE_FrostcallerAura_DO")),
		new TooltipLinkDef("StaffFrostcallerShotgunDO", TooltipAttackSlot.Secondary, new TooltipTextLine("$aoe_area_spawn_DO"), new TooltipTextLine("$aoe_area_obstacle_DO")),
		new TooltipLinkDef("StaffFirecallerRingDO", TooltipAttackSlot.Secondary, "SE_FirecallerOrbit_DO"),
		new TooltipLinkDef("StaffStonecallerBurstDO", TooltipAttackSlot.Secondary, new TooltipTextLine("$aoe_area_obstacle_DO")),
		new TooltipLinkDef("StaffWindcallerBuffDO", TooltipAttackSlot.Main, "SE_WindcallerShield_DO"),
		new TooltipLinkDef("StaffWindcallerBuffDO", TooltipAttackSlot.Secondary, "SE_WindcallerPetal_DO"),
		new TooltipLinkDef("StaffLightcallerHealDO", TooltipAttackSlot.Main, new TooltipTextLine("$aoe_trap_heal_DO"), new TooltipInlineLine(new TooltipInlinePart("$heal_DO"), new TooltipInlinePart(": "), new TooltipInlinePart("40", "orange"))),
		new TooltipLinkDef("StaffLightcallerHealDO", TooltipAttackSlot.Secondary, "SE_LightcallerHeal_DO"),
		new TooltipLinkDef("StaffLightcallerSphereDO", TooltipAttackSlot.Secondary, new TooltipTextLine("$aoe_area_light_DO"), new TooltipTextLine("$aoe_area_damage_DO")),
		new TooltipLinkDef("StaffStormcallerSphereDO", TooltipAttackSlot.Secondary, new TooltipTextLine("$aoe_trap_damage_DO")),
		new TooltipLinkDef("StaffStormcallerShockerDO", TooltipAttackSlot.Secondary, "SE_StormcallerOrbit_DO"),
		new TooltipLinkDef("StaffBloodcallerHealDO", TooltipAttackSlot.Main, "SE_BloodcallerHeal_DO"),
		new TooltipLinkDef("StaffBloodcallerHealDO", TooltipAttackSlot.Secondary, "SE_BloodBuff_DO"),
		new TooltipLinkDef("StaffBloodcallerShotgunDO", TooltipAttackSlot.Secondary, new TooltipTextLine("$aoe_area_damage_DO"), new TooltipTextLine(" "), new TooltipTextLine("$aoe_area_debuff_DO"), new TooltipTextLine(" "), new TooltipSELine("SE_BloodDebuff_DO"))
	};

	private static void AppendEntriesForSlot(StringBuilder sb, List<TooltipLinkDef> itemDefs, TooltipAttackSlot slot, int qualityLevel, float skillLevel)
	{
		bool flag = false;
		foreach (TooltipLinkDef itemDef in itemDefs)
		{
			if (itemDef.AttackSlot != slot)
			{
				continue;
			}
			string value = BuildDefTooltip(itemDef, qualityLevel, skillLevel);
			if (string.IsNullOrEmpty(value))
			{
				continue;
			}
			if (!flag)
			{
				if (sb.Length > 0)
				{
					sb.Append("\n\n");
				}
				sb.Append(GetAttackHeader(slot));
				sb.Append("\n");
				flag = true;
			}
			else
			{
				sb.Append("\n\n");
			}
			sb.Append(value);
		}
	}

	private static string BuildDefTooltip(TooltipLinkDef def, int qualityLevel, float skillLevel)
	{
		if (def == null || def.Entries == null || def.Entries.Count == 0)
		{
			return "";
		}
		StringBuilder stringBuilder = new StringBuilder();
		foreach (TooltipEntry entry in def.Entries)
		{
			if (entry == null)
			{
				continue;
			}
			string value = entry.Build(def.ItemPrefabName, qualityLevel, skillLevel);
			if (!string.IsNullOrEmpty(value))
			{
				if (stringBuilder.Length > 0)
				{
					stringBuilder.Append("\n");
				}
				stringBuilder.Append(value);
			}
		}
		return stringBuilder.ToString();
	}

	private static string BuildVanillaStatusEffectTooltip(StatusEffect statusEffect, int qualityLevel, float skillLevel)
	{
		if ((Object)(object)statusEffect == (Object)null)
		{
			return "";
		}
		statusEffect.SetLevel(qualityLevel, skillLevel);
		return "<color=orange>" + statusEffect.m_name + "</color>\n" + statusEffect.GetTooltipString();
	}

	private static string GetAttackHeader(TooltipAttackSlot slot)
	{
		return slot switch
		{
			TooltipAttackSlot.Main => Colorize(Localize("$main_attack_DO"), "#FFC654"), 
			TooltipAttackSlot.Secondary => Colorize(Localize("$secondary_attack_DO"), "#FFC654"), 
			_ => "", 
		};
	}

	private static string Colorize(string text, string color)
	{
		if (string.IsNullOrEmpty(text))
		{
			return "";
		}
		if (string.IsNullOrEmpty(color))
		{
			return text;
		}
		return "<color=" + color + ">" + text + "</color>";
	}

	private static string Localize(string keyOrText)
	{
		if (string.IsNullOrEmpty(keyOrText))
		{
			return "";
		}
		if (Localization.instance == null)
		{
			return keyOrText;
		}
		if (keyOrText.StartsWith("$"))
		{
			return Localization.instance.Localize(keyOrText);
		}
		return keyOrText;
	}

	private static List<TooltipLinkDef> GetDefsForItem(string itemPrefabName)
	{
		List<TooltipLinkDef> list = new List<TooltipLinkDef>();
		foreach (TooltipLinkDef def in Defs)
		{
			if (def.ItemPrefabName == itemPrefabName)
			{
				list.Add(def);
			}
		}
		return list;
	}

	private static StatusEffect FindStatusEffect(string statusEffectPrefabName)
	{
		if ((Object)(object)ObjectDB.instance == (Object)null)
		{
			return null;
		}
		foreach (StatusEffect statusEffect in ObjectDB.instance.m_StatusEffects)
		{
			if (!((Object)(object)statusEffect == (Object)null))
			{
				if (((Object)statusEffect).name == statusEffectPrefabName)
				{
					return statusEffect;
				}
				if (Utils.GetPrefabName(((Object)statusEffect).name) == statusEffectPrefabName)
				{
					return statusEffect;
				}
			}
		}
		return null;
	}

	private static string GetItemPrefabName(ItemData item)
	{
		if (item == null)
		{
			return "";
		}
		if ((Object)(object)item.m_dropPrefab != (Object)null)
		{
			return Utils.GetPrefabName(((Object)item.m_dropPrefab).name);
		}
		if (item.m_shared != null && !string.IsNullOrEmpty(item.m_shared.m_name))
		{
			GameObject val = (((Object)(object)ObjectDB.instance != (Object)null) ? ObjectDB.instance.GetItemPrefab(item.m_shared.m_name) : null);
			if ((Object)(object)val != (Object)null)
			{
				return Utils.GetPrefabName(((Object)val).name);
			}
		}
		return "";
	}

	private static void DLog(string message)
	{
	}
}
[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
public static class ItemDropExtendedStats
{
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
	private static class DevLog
	{
		public const bool Enabled = false;

		public const bool Skill = false;

		public const bool CarryWeight = false;

		public const bool MovementSpeed = false;

		public const bool Adrenaline = false;

		public const bool Tooltips = false;
	}

	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
	public enum ExtendedStatType
	{
		SkillLevelBonus,
		CarryWeightBonus,
		MovementSpeedModifier,
		AdrenalineGainModifier
	}

	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	public class ExtendedStatEntry
	{
		public string PrefabName;

		public ExtendedStatType StatType;

		public SkillType SkillType;

		public float Value;

		public ExtendedStatEntry(string prefab, ExtendedStatType statType, float value)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			PrefabName = prefab;
			StatType = statType;
			SkillType = (SkillType)0;
			Value = value;
		}

		public ExtendedStatEntry(string prefab, ExtendedStatType statType, SkillType skillType, float value)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			PrefabName = prefab;
			StatType = statType;
			SkillType = skillType;
			Value = value;
		}
	}

	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
	[HarmonyPatch(typeof(Skills), "GetSkillLevel")]
	public static class Skills_GetSkillLevel_ItemDropExtendedStatsPatch
	{
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
		private static void Postfix(Skills __instance, SkillType skillType, ref float __result)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)__instance == (Object)null)
				{
					return;
				}
				Player player = __instance.m_player;
				if (!((Object)(object)player == (Object)null) && (int)skillType != 0)
				{
					float equippedSkillBonus = GetEquippedSkillBonus(player, skillType);
					if (equippedSkillBonus != 0f)
					{
						__result += equippedSkillBonus;
						DLogSkill($"Applied item-based skill bonus to {skillType}: +{equippedSkillBonus}, result={__result}");
					}
				}
			}
			catch (Exception ex)
			{
				LogError("Exception in Skills_GetSkillLevel_ItemDropExtendedStatsPatch: " + ex);
			}
		}
	}

	[HarmonyPatch(typeof(Player), "GetMaxCarryWeight")]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
	public static class Player_GetMaxCarryWeight_ItemDropExtendedStatsPatch
	{
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
		private static void Postfix(Player __instance, ref float __result)
		{
			try
			{
				if (!((Object)(object)__instance == (Object)null))
				{
					float equippedBonusByType = GetEquippedBonusByType(__instance, ExtendedStatType.CarryWeightBonus);
					if (equippedBonusByType != 0f)
					{
						__result += equippedBonusByType;
						DLogCarry($"Applied item-based carry weight bonus: +{equippedBonusByType}, result={__result}");
					}
				}
			}
			catch (Exception ex)
			{
				LogError("Exception in Player_GetMaxCarryWeight_ItemDropExtendedStatsPatch: " + ex);
			}
		}
	}

	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
	[HarmonyPatch(typeof(SEMan), "ApplyStatusEffectSpeedMods")]
	public static class SEMan_ApplyStatusEffectSpeedMods_ItemDropExtendedStatsPatch
	{
		private static void Prefix(ref float speed, out float __state)
		{
			__state = speed;
		}

		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
		private static void Postfix(SEMan __instance, ref float speed, Vector3 dir, float __state)
		{
			try
			{
				Player playerFromSEMan = GetPlayerFromSEMan(__instance);
				if ((Object)(object)playerFromSEMan == (Object)null)
				{
					return;
				}
				float equippedBonusByType = GetEquippedBonusByType(playerFromSEMan, ExtendedStatType.MovementSpeedModifier);
				if (equippedBonusByType != 0f)
				{
					speed += __state * equippedBonusByType;
					if (speed < 0f)
					{
						speed = 0f;
					}
					DLogMovement($"Applied item-based movement speed modifier: {equippedBonusByType * 100f:+0;-0}% baseSpeed={__state}, result={speed}");
				}
			}
			catch (Exception ex)
			{
				LogError("Exception in SEMan_ApplyStatusEffectSpeedMods_ItemDropExtendedStatsPatch: " + ex);
			}
		}
	}

	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
	[HarmonyPatch(typeof(SEMan), "ModifyAdrenaline")]
	public static class SEMan_ModifyAdrenaline_ItemDropExtendedStatsPatch
	{
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
		private static void Postfix(SEMan __instance, float baseValue, ref float use)
		{
			try
			{
				Player playerFromSEMan = GetPlayerFromSEMan(__instance);
				if (!((Object)(object)playerFromSEMan == (Object)null))
				{
					float equippedBonusByType = GetEquippedBonusByType(playerFromSEMan, ExtendedStatType.AdrenalineGainModifier);
					if (equippedBonusByType != 0f)
					{
						use += baseValue * equippedBonusByType;
						DLogAdrenaline($"Applied item-based adrenaline gain modifier: {equippedBonusByType * 100f:+0;-0}% baseValue={baseValue}, result={use}");
					}
				}
			}
			catch (Exception ex)
			{
				LogError("Exception in SEMan_ModifyAdrenaline_ItemDropExtendedStatsPatch: " + ex);
			}
		}
	}

	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[HarmonyPatch]
	public static class ItemData_StaticGetTooltip_ItemDropExtendedStatsPatch
	{
		private static MethodBase TargetMethod()
		{
			return AccessTools.Method(typeof(ItemData), "GetTooltip", new Type[5]
			{
				typeof(ItemData),
				typeof(int),
				typeof(bool),
				typeof(float),
				typeof(int)
			}, (Type[])null);
		}

		private static void Postfix(ItemData item, int qualityLevel, bool crafting, float worldLevel, int stackOverride, ref string __result)
		{
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (item == null || (Object)(object)item.m_dropPrefab == (Object)null)
				{
					return;
				}
				string name = ((Object)item.m_dropPrefab).name;
				DLogTooltip($"Static GetTooltip Postfix called for {name}, q={qualityLevel}, crafting={crafting}, worldLevel={worldLevel}, stackOverride={stackOverride}");
				string text = BuildExtendedTooltipBlock(item);
				if (string.IsNullOrEmpty(text))
				{
					return;
				}
				float num = 0f;
				if ((Object)(object)Player.m_localPlayer != (Object)null)
				{
					num = ((Character)Player.m_localPlayer).GetSkillLevel(item.m_shared.m_skillType);
				}
				string statusEffectTooltip = item.GetStatusEffectTooltip(qualityLevel, num);
				string chainTooltip = item.GetChainTooltip(qualityLevel, num);
				string setStatusEffectTooltip = item.GetSetStatusEffectTooltip(qualityLevel, num);
				int num2 = -1;
				if (!string.IsNullOrEmpty(statusEffectTooltip))
				{
					int num3 = __result.IndexOf(statusEffectTooltip, StringComparison.Ordinal);
					if (num3 >= 0)
					{
						num2 = ((num3 - 2 >= 0 && __result.Substring(num3 - 2, 2) == "\n\n") ? (num3 - 2) : num3);
					}
				}
				if (num2 < 0 && !string.IsNullOrEmpty(chainTooltip))
				{
					int num4 = __result.IndexOf(chainTooltip, StringComparison.Ordinal);
					if (num4 >= 0)
					{
						num2 = ((num4 - 2 >= 0 && __result.Substring(num4 - 2, 2) == "\n\n") ? (num4 - 2) : num4);
					}
				}
				if (num2 < 0)
				{
					int num5 = __result.IndexOf("\n$item_eitrregen_modifier:", StringComparison.Ordinal);
					if (num5 >= 0)
					{
						num2 = num5;
					}
				}
				if (num2 < 0 && !string.IsNullOrEmpty(setStatusEffectTooltip))
				{
					int num6 = __result.IndexOf("\n\n$item_seteffect", StringComparison.Ordinal);
					if (num6 >= 0)
					{
						num2 = num6;
					}
				}
				if (num2 < 0)
				{
					int num7 = __result.IndexOf("\n$item_fulladrenaline:", StringComparison.Ordinal);
					if (num7 >= 0)
					{
						num2 = num7;
					}
				}
				if (num2 >= 0)
				{
					DLogTooltip("Inserting extended ItemDrop stats before special/effect section for " + name);
					__result = __result.Insert(num2, text);
				}
				else
				{
					DLogTooltip("No special/effect section found, appending extended ItemDrop stats at end for " + name);
					__result += text;
				}
			}
			catch (Exception ex)
			{
				LogError("Exception in ItemData_StaticGetTooltip_ItemDropExtendedStatsPatch: " + ex);
			}
		}
	}

	public static readonly List<ExtendedStatEntry> ExtendedStatsConfig = new List<ExtendedStatEntry>
	{
		new ExtendedStatEntry("ArmorInspirationTrinketMountainDO", ExtendedStatType.SkillLevelBonus, (SkillType)9, 2f),
		new ExtendedStatEntry("ArmorInspirationTrinketPlainsDO", ExtendedStatType.SkillLevelBonus, (SkillType)9, 2f),
		new ExtendedStatEntry("ArmorInspirationTrinketMistlandsDO", ExtendedStatType.SkillLevelBonus, (SkillType)9, 2f),
		new ExtendedStatEntry("ArmorInspirationTrinketAshlandsDO", ExtendedStatType.SkillLevelBonus, (SkillType)9, 2f),
		new ExtendedStatEntry("ArmorMushroomcallerChestDO", ExtendedStatType.SkillLevelBonus, (SkillType)9, 2f),
		new ExtendedStatEntry("ArmorTotemcallerChestDO", ExtendedStatType.SkillLevelBonus, (SkillType)9, 2f),
		new ExtendedStatEntry("ArmorDeathcallerLegsDO", ExtendedStatType.SkillLevelBonus, (SkillType)9, 4f),
		new ExtendedStatEntry("ArmorFrostcallerHelmetDO", ExtendedStatType.SkillLevelBonus, (SkillType)9, 6f),
		new ExtendedStatEntry("ArmorFirecallerChestDO", ExtendedStatType.SkillLevelBonus, (SkillType)9, 8f),
		new ExtendedStatEntry("ArmorStonecallerChestDO", ExtendedStatType.SkillLevelBonus, (SkillType)9, 8f),
		new ExtendedStatEntry("ArmorWindcallerLegsDO", ExtendedStatType.SkillLevelBonus, (SkillType)9, 10f),
		new ExtendedStatEntry("ArmorLightcallerLegsDO", ExtendedStatType.SkillLevelBonus, (SkillType)9, 10f),
		new ExtendedStatEntry("ArmorStormcallerHelmetDO", ExtendedStatType.SkillLevelBonus, (SkillType)9, 12f),
		new ExtendedStatEntry("ArmorBloodcallerHelmetDO", ExtendedStatType.SkillLevelBonus, (SkillType)10, 12f),
		new ExtendedStatEntry("ArmorTotemcallerCapeDO", ExtendedStatType.MovementSpeedModifier, 0.04f),
		new ExtendedStatEntry("ArmorMushroomcallerCapeDO", ExtendedStatType.CarryWeightBonus, 20f),
		new ExtendedStatEntry("ArmorFirecallerCapeDO", ExtendedStatType.AdrenalineGainModifier, 0.15f),
		new ExtendedStatEntry("ArmorStormcallerCapeDO", ExtendedStatType.MovementSpeedModifier, 0.09f),
		new ExtendedStatEntry("ArmorBloodcallerCapeDO", ExtendedStatType.SkillLevelBonus, (SkillType)10, 20f)
	};

	private static FieldRef<SEMan, Character> _semanCharacterRef;

	private static bool _semanInit;

	private static void DLogSkill(string msg)
	{
	}

	private static void DLogCarry(string msg)
	{
	}

	private static void DLogMovement(string msg)
	{
	}

	private static void DLogAdrenaline(string msg)
	{
	}

	private static void DLogTooltip(string msg)
	{
	}

	private static void LogError(string msg)
	{
	}

	private static void EnsureSEManInit()
	{
		if (!_semanInit)
		{
			_semanInit = true;
			_semanCharacterRef = AccessTools.FieldRefAccess<SEMan, Character>("m_character");
		}
	}

	private static Player GetPlayerFromSEMan(SEMan seman)
	{
		if (seman == null)
		{
			return null;
		}
		try
		{
			EnsureSEManInit();
			Character obj = _semanCharacterRef.Invoke(seman);
			return (Player)(object)((obj is Player) ? obj : null);
		}
		catch (Exception ex)
		{
			LogError("Exception in GetPlayerFromSEMan: " + ex);
			return null;
		}
	}

	private static float GetEquippedSkillBonus(Player player, SkillType requestedSkill)
	{
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a3: Invalid comparison between Unknown and I4
		//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)player == (Object)null)
		{
			return 0f;
		}
		float num = 0f;
		try
		{
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory == null)
			{
				return 0f;
			}
			List<ItemData> equippedItems = inventory.GetEquippedItems();
			for (int i = 0; i < equippedItems.Count; i++)
			{
				ItemData val = equippedItems[i];
				if (val == null || (Object)(object)val.m_dropPrefab == (Object)null)
				{
					continue;
				}
				string name = ((Object)val.m_dropPrefab).name;
				for (int j = 0; j < ExtendedStatsConfig.Count; j++)
				{
					ExtendedStatEntry extendedStatEntry = ExtendedStatsConfig[j];
					if (extendedStatEntry.StatType == ExtendedStatType.SkillLevelBonus && string.Equals(name, extendedStatEntry.PrefabName, StringComparison.OrdinalIgnoreCase) && ((int)extendedStatEntry.SkillType == 999 || extendedStatEntry.SkillType == requestedSkill))
					{
						num += extendedStatEntry.Value;
						DLogSkill($"Matched {name} for {requestedSkill}: +{extendedStatEntry.Value}");
					}
				}
			}
		}
		catch (Exception ex)
		{
			LogError("Exception in GetEquippedSkillBonus: " + ex);
		}
		return num;
	}

	private static float GetEquippedBonusByType(Player player, ExtendedStatType statType)
	{
		if ((Object)(object)player == (Object)null)
		{
			return 0f;
		}
		float num = 0f;
		try
		{
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory == null)
			{
				return 0f;
			}
			List<ItemData> equippedItems = inventory.GetEquippedItems();
			for (int i = 0; i < equippedItems.Count; i++)
			{
				ItemData val = equippedItems[i];
				if (val == null || (Object)(object)val.m_dropPrefab == (Object)null)
				{
					continue;
				}
				string name = ((Object)val.m_dropPrefab).name;
				for (int j = 0; j < ExtendedStatsConfig.Count; j++)
				{
					ExtendedStatEntry extendedStatEntry = ExtendedStatsConfig[j];
					if (extendedStatEntry.StatType == statType && string.Equals(name, extendedStatEntry.PrefabName, StringComparison.OrdinalIgnoreCase))
					{
						num += extendedStatEntry.Value;
					}
				}
			}
		}
		catch (Exception ex)
		{
			LogError($"Exception in GetEquippedBonusByType({statType}): " + ex);
		}
		return num;
	}

	private static string BuildExtendedTooltipBlock(ItemData item)
	{
		if (item == null || (Object)(object)item.m_dropPrefab == (Object)null)
		{
			return string.Empty;
		}
		string name = ((Object)item.m_dropPrefab).name;
		StringBuilder stringBuilder = new StringBuilder();
		for (int i = 0; i < ExtendedStatsConfig.Count; i++)
		{
			ExtendedStatEntry extendedStatEntry = ExtendedStatsConfig[i];
			if (!string.Equals(name, extendedStatEntry.PrefabName, StringComparison.OrdinalIgnoreCase))
			{
				continue;
			}
			switch (extendedStatEntry.StatType)
			{
			case ExtendedStatType.SkillLevelBonus:
			{
				string text = "$skill_" + ((object)(SkillType)(ref extendedStatEntry.SkillType)).ToString().ToLower();
				string arg = text;
				if (Localization.instance != null)
				{
					arg = Localization.instance.Localize(text);
				}
				stringBuilder.AppendFormat("\n{0} <color=orange>{1}</color>", arg, extendedStatEntry.Value.ToString("+0;-0"));
				break;
			}
			case ExtendedStatType.CarryWeightBonus:
				stringBuilder.AppendFormat("\n$se_max_carryweight: <color=orange>{0}</color>", extendedStatEntry.Value.ToString("+0;-0"));
				break;
			case ExtendedStatType.MovementSpeedModifier:
				stringBuilder.AppendFormat("\n$item_movement_modifier: <color=orange>{0}%</color>", (extendedStatEntry.Value * 100f).ToString("+0;-0"));
				break;
			case ExtendedStatType.AdrenalineGainModifier:
				stringBuilder.AppendFormat("\n$se_adrenaline: <color=orange>{0}%</color>", (extendedStatEntry.Value * 100f).ToString("+0;-0"));
				break;
			}
		}
		return stringBuilder.ToString();
	}
}
[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
public static class TooltipColor
{
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	private class StatusEffectTextColorDef
	{
		public readonly string StatusEffectPrefabName;

		public readonly string TooltipColor;

		public StatusEffectTextColorDef(string statusEffectPrefabName, string tooltipColor)
		{
			StatusEffectPrefabName = statusEffectPrefabName;
			TooltipColor = tooltipColor;
		}
	}

	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
	[HarmonyPatch(typeof(SE_Stats), "GetTooltipString")]
	private static class SE_Stats_GetTooltipString_TooltipColorPatch
	{
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
		private static void Postfix(SE_Stats __instance, ref string __result)
		{
			try
			{
				if (!((Object)(object)__instance == (Object)null) && !string.IsNullOrEmpty(__result))
				{
					StatusEffectTextColorDef statusEffectTextColorDef = GetStatusEffectTextColorDef(Utils.GetPrefabName(((Object)__instance).name));
					if (statusEffectTextColorDef != null && !string.IsNullOrEmpty(statusEffectTextColorDef.TooltipColor))
					{
						ApplyTooltipDescriptionColor(__instance, statusEffectTextColorDef.TooltipColor, ref __result);
					}
				}
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("[TooltipColor] ERROR: " + ex));
			}
		}
	}

	private static readonly List<StatusEffectTextColorDef> StatusEffectTextColorDefs = new List<StatusEffectTextColorDef>
	{
		new StatusEffectTextColorDef("SE_MushroomcallerArmor_DO", "#f0bdff"),
		new StatusEffectTextColorDef("SE_TotemcallerArmor_DO", "#f0bdff"),
		new StatusEffectTextColorDef("SE_DeathcallerArmor_DO", "#f0bdff"),
		new StatusEffectTextColorDef("SE_FrostcallerArmor_DO", "#f0bdff"),
		new StatusEffectTextColorDef("SE_FirecallerArmor_DO", "#f0bdff"),
		new StatusEffectTextColorDef("SE_StonecallerArmor_DO", "#f0bdff"),
		new StatusEffectTextColorDef("SE_WindcallerArmor_DO", "#f0bdff"),
		new StatusEffectTextColorDef("SE_LightcallerArmor_DO", "#f0bdff"),
		new StatusEffectTextColorDef("SE_StormcallerArmor_DO", "#f0bdff"),
		new StatusEffectTextColorDef("SE_BloodcallerArmor_DO", "#f0bdff")
	};

	private static void ApplyTooltipDescriptionColor(SE_Stats se, string color, ref string result)
	{
		if ((Object)(object)se == (Object)null || string.IsNullOrEmpty(color))
		{
			return;
		}
		string tooltip = ((StatusEffect)se).m_tooltip;
		if (!string.IsNullOrEmpty(tooltip))
		{
			if (result.StartsWith(tooltip + "\n\n"))
			{
				result = Colorize(tooltip, color) + result.Substring(tooltip.Length);
			}
			else if (result.StartsWith(tooltip + "\n"))
			{
				result = Colorize(tooltip, color) + result.Substring(tooltip.Length);
			}
			else if (result == tooltip)
			{
				result = Colorize(tooltip, color);
			}
		}
	}

	private static StatusEffectTextColorDef GetStatusEffectTextColorDef(string sePrefabName)
	{
		if (string.IsNullOrEmpty(sePrefabName))
		{
			return null;
		}
		foreach (StatusEffectTextColorDef statusEffectTextColorDef in StatusEffectTextColorDefs)
		{
			if (statusEffectTextColorDef != null && statusEffectTextColorDef.StatusEffectPrefabName == sePrefabName)
			{
				return statusEffectTextColorDef;
			}
		}
		return null;
	}

	private static string Colorize(string text, string color)
	{
		if (string.IsNullOrEmpty(text))
		{
			return "";
		}
		if (string.IsNullOrEmpty(color))
		{
			return text;
		}
		return "<color=" + color + ">" + text + "</color>";
	}
}
[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
internal sealed class ConfigurationManagerAttributes
{
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
	public delegate void CustomHotkeyDrawerFunc(ConfigEntryBase setting, ref bool isCurrentlyAcceptingInput);

	public bool? ShowRangeAsPercent;

	public Action<ConfigEntryBase> CustomDrawer;

	public CustomHotkeyDrawerFunc CustomHotkeyDrawer;

	public bool? Browsable;

	public string Category;

	public object DefaultValue;

	public bool? HideDefaultButton;

	public bool? HideSettingName;

	public string Description;

	public string DispName;

	public int? Order;

	public bool? ReadOnly;

	public bool? IsAdvanced;

	public Func<object, string> ObjToStr;

	public Func<string, object> StrToObj;
}
[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
public static class ExtraStats
{
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
	private static class DevLog
	{
		public const bool Enabled = false;

		public const bool AttackSpeed = false;

		public const bool WetImmune = false;

		public const bool Tooltips = false;

		public const bool FoodStats = false;
	}

	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
	public enum ExtraStatType
	{
		Health,
		Stamina,
		Eitr,
		AttackSpeed,
		WetImmune
	}

	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
	public enum ExtraSourceType
	{
		ItemDrop,
		StatusEffect
	}

	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	public class ExtraStatEntry
	{
		public string PrefabName;

		public ExtraStatType StatType;

		public float Value;

		public float? DisplayValue;

		public ExtraSourceType SourceType;

		public ExtraStatEntry(string prefab, ExtraStatType stat, float value, ExtraSourceType source)
		{
			PrefabName = prefab;
			StatType = stat;
			Value = value;
			DisplayValue = null;
			SourceType = source;
		}

		public ExtraStatEntry(string prefab, ExtraStatType stat, float value, float? displayValue, ExtraSourceType source)
		{
			PrefabName = prefab;
			StatType = stat;
			Value = value;
			DisplayValue = displayValue;
			SourceType = source;
		}
	}

	[HarmonyPatch(typeof(Player), "GetTotalFoodValue")]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
	public static class Player_GetTotalFoodValue_ExtraStatsPatch
	{
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
		private static void Postfix(Player __instance, ref float hp, ref float stamina, ref float eitr)
		{
			if ((Object)(object)__instance == (Object)null)
			{
				return;
			}
			float num = 0f;
			float num2 = 0f;
			float num3 = 0f;
			try
			{
				Inventory inventory = ((Humanoid)__instance).GetInventory();
				if (inventory != null)
				{
					foreach (ItemData equippedItem in inventory.GetEquippedItems())
					{
						if (equippedItem != null && !((Object)(object)equippedItem.m_dropPrefab == (Object)null))
						{
							string name = ((Object)equippedItem.m_dropPrefab).name;
							GetItemDropBonusesForPrefab(name, out var extraHp, out var extraStamina, out var extraEitr, out var _, out var _);
							if (extraHp != 0f || extraStamina != 0f || extraEitr != 0f)
							{
								num += extraHp;
								num2 += extraStamina;
								num3 += extraEitr;
								DLogFood($"ItemDrop matched for food stats: {name} → +HP {extraHp}, +Stamina {extraStamina}, +Eitr {extraEitr}");
							}
						}
					}
				}
				if (((Character)__instance).m_seman != null && ((Character)__instance).m_seman.m_statusEffects != null)
				{
					foreach (StatusEffect statusEffect in ((Character)__instance).m_seman.m_statusEffects)
					{
						if (!((Object)(object)statusEffect == (Object)null))
						{
							string name2 = ((Object)statusEffect).name;
							GetStatusEffectBonuses(name2, out var extraHp2, out var extraStamina2, out var extraEitr2, out var _, out var _);
							if (extraHp2 != 0f || extraStamina2 != 0f || extraEitr2 != 0f)
							{
								num += extraHp2;
								num2 += extraStamina2;
								num3 += extraEitr2;
								string prefabName = Utils.GetPrefabName(name2);
								DLogFood($"StatusEffect matched for food stats: {name2} (clean={prefabName}) → +HP {extraHp2}, +Stamina {extraStamina2}, +Eitr {extraEitr2}");
							}
						}
					}
				}
			}
			catch (Exception ex)
			{
				LogError("Exception in ExtraStats Player.GetTotalFoodValue Postfix: " + ex);
			}
			if (num != 0f || num2 != 0f || num3 != 0f)
			{
				DLogFood($"Total food bonuses applied to player: +HP {num}, +Stamina {num2}, +Eitr {num3}");
				hp += num;
				stamina += num2;
				eitr += num3;
			}
		}
	}

	[HarmonyPatch]
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	public static class ItemData_StaticGetTooltip_ExtraStatsPatch
	{
		private static MethodBase TargetMethod()
		{
			return AccessTools.Method(typeof(ItemData), "GetTooltip", new Type[5]
			{
				typeof(ItemData),
				typeof(int),
				typeof(bool),
				typeof(float),
				typeof(int)
			}, (Type[])null);
		}

		private static void Postfix(ItemData item, int qualityLevel, bool crafting, float worldLevel, int stackOverride, ref string __result)
		{
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (item == null || (Object)(object)item.m_dropPrefab == (Object)null)
				{
					return;
				}
				string name = ((Object)item.m_dropPrefab).name;
				DLogTooltip($"Static GetTooltip Postfix called for {name}, q={qualityLevel}, crafting={crafting}, worldLevel={worldLevel}, stackOverride={stackOverride}");
				GetItemDropBonusesForPrefab(name, out var extraHp, out var extraStamina, out var extraEitr, out var _, out var displayAttackSpeedPercent, out var wetImmune);
				if (extraHp == 0f && extraStamina == 0f && extraEitr == 0f && displayAttackSpeedPercent == 0f && !wetImmune)
				{
					return;
				}
				string text = BuildExtraStatsTooltipBlock(extraHp, extraStamina, extraEitr, displayAttackSpeedPercent, wetImmune);
				if (string.IsNullOrEmpty(text))
				{
					return;
				}
				float num = 0f;
				if ((Object)(object)Player.m_localPlayer != (Object)null)
				{
					num = ((Character)Player.m_localPlayer).GetSkillLevel(item.m_shared.m_skillType);
				}
				string statusEffectTooltip = item.GetStatusEffectTooltip(qualityLevel, num);
				string chainTooltip = item.GetChainTooltip(qualityLevel, num);
				string setStatusEffectTooltip = item.GetSetStatusEffectTooltip(qualityLevel, num);
				int num2 = -1;
				if (!string.IsNullOrEmpty(statusEffectTooltip))
				{
					int num3 = __result.IndexOf(statusEffectTooltip, StringComparison.Ordinal);
					if (num3 >= 0)
					{
						num2 = ((num3 - 2 >= 0 && __result.Substring(num3 - 2, 2) == "\n\n") ? (num3 - 2) : num3);
					}
				}
				if (num2 < 0 && !string.IsNullOrEmpty(chainTooltip))
				{
					int num4 = __result.IndexOf(chainTooltip, StringComparison.Ordinal);
					if (num4 >= 0)
					{
						num2 = ((num4 - 2 >= 0 && __result.Substring(num4 - 2, 2) == "\n\n") ? (num4 - 2) : num4);
					}
				}
				if (num2 < 0)
				{
					int num5 = __result.IndexOf("\n$item_eitrregen_modifier:", StringComparison.Ordinal);
					if (num5 >= 0)
					{
						num2 = num5;
					}
				}
				if (num2 < 0 && !string.IsNullOrEmpty(setStatusEffectTooltip))
				{
					int num6 = __result.IndexOf("\n\n$item_seteffect", StringComparison.Ordinal);
					if (num6 >= 0)
					{
						num2 = num6;
					}
				}
				if (num2 < 0)
				{
					int num7 = __result.IndexOf("\n$item_fulladrenaline:", StringComparison.Ordinal);
					if (num7 >= 0)
					{
						num2 = num7;
					}
				}
				if (num2 >= 0)
				{
					DLogTooltip("Inserting ItemDrop extras before special/effect section for " + name);
					__result = __result.Insert(num2, text);
				}
				else
				{
					DLogTooltip("No special/effect section found, appending ItemDrop extras at end for " + name);
					__result += text;
				}
			}
			catch (Exception ex)
			{
				LogError("Exception in ItemData_StaticGetTooltip_ExtraStatsPatch: " + ex);
			}
		}
	}

	[HarmonyPatch(typeof(SE_Stats), "GetTooltipString")]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
	public static class SE_Stats_GetTooltipString_ExtraStatsPatch
	{
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
		private static void Postfix(SE_Stats __instance, ref string __result)
		{
			try
			{
				if ((Object)(object)__instance == (Object)null)
				{
					return;
				}
				string name = ((Object)__instance).name;
				string prefabName = Utils.GetPrefabName(name);
				DLogTooltip("SE GetTooltipString for " + name + " (clean=" + prefabName + ")");
				GetStatusEffectBonuses(name, out var extraHp, out var extraStamina, out var extraEitr, out var _, out var displayAttackSpeedPercent, out var wetImmune);
				if (extraHp == 0f && extraStamina == 0f && extraEitr == 0f && displayAttackSpeedPercent == 0f && !wetImmune)
				{
					return;
				}
				string text = BuildExtraStatsTooltipBlock(extraHp, extraStamina, extraEitr, displayAttackSpeedPercent, wetImmune);
				if (!string.IsNullOrEmpty(text))
				{
					if (text.StartsWith("\n"))
					{
						text = text.Substring(1);
					}
					DLogTooltip($"Appending SE extras for {name} (clean={prefabName}): HP {extraHp}, Stamina {extraStamina}, Eitr {extraEitr}, AttackSpeed(Display)% {displayAttackSpeedPercent}, WetImmune {wetImmune}");
					__result += text;
				}
			}
			catch (Exception ex)
			{
				LogError("Exception in SE_Stats_GetTooltipString_ExtraStatsPatch: " + ex);
			}
		}
	}

	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
	private sealed class HumanoidState
	{
		public float DesiredSpeed = 1f;

		public float LastAppliedSpeed = 1f;

		public bool HasDesiredSpeed;

		public bool WasInAttack;

		public int ActiveAttackDepth;

		public float ActiveAttackMul = 1f;
	}

	[HarmonyPatch(typeof(Humanoid), "StartAttack", new Type[]
	{
		typeof(Character),
		typeof(bool)
	})]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
	public static class Humanoid_StartAttack_AttackSpeedPatch
	{
		[HarmonyPostfix]
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
		private static void Postfix(Humanoid __instance, Character target, bool secondaryAttack, ref bool __result)
		{
			EnsureAttackInit();
			if (!__result)
			{
				return;
			}
			HumanoidState attackState = GetAttackState(__instance);
			float num = ComputeTotalAttackSpeedPercentForHumanoid(__instance);
			if (num == 0f)
			{
				attackState.DesiredSpeed = 1f;
				attackState.HasDesiredSpeed = false;
				ApplyAnimSpeed(__instance, attackState, 1f);
				attackState.ActiveAttackDepth = 0;
				attackState.ActiveAttackMul = 1f;
				return;
			}
			float num2 = 1f + num / 100f;
			if (num2 <= 0f || float.IsNaN(num2) || float.IsInfinity(num2))
			{
				attackState.DesiredSpeed = 1f;
				attackState.HasDesiredSpeed = false;
				ApplyAnimSpeed(__instance, attackState, 1f);
				attackState.ActiveAttackDepth = 0;
				attackState.ActiveAttackMul = 1f;
			}
			else
			{
				attackState.DesiredSpeed = num2;
				attackState.HasDesiredSpeed = true;
				ApplyAnimSpeed(__instance, attackState, num2);
				attackState.ActiveAttackDepth++;
				attackState.ActiveAttackMul = num2;
				DLogAttackSpeed($"StartAttack: total AttackSpeed%={num} → mul={num2} (activeDepth={attackState.ActiveAttackDepth})");
			}
		}
	}

	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
	[HarmonyPatch(typeof(Attack), "Stop")]
	public static class Attack_Stop_AttackSpeedResetPatch
	{
		[HarmonyPostfix]
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
		private static void Postfix(Attack __instance)
		{
			try
			{
				EnsureAttackInit();
				if (__instance != null)
				{
					Humanoid character = __instance.m_character;
					if (!((Object)(object)character == (Object)null))
					{
						ResetForHumanoid(character);
						DLogAttackSpeed("Attack.Stop: ResetForHumanoid");
					}
				}
			}
			catch (Exception)
			{
			}
		}
	}

	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
	[HarmonyPatch(typeof(Humanoid), "UpdateAttack")]
	public static class Humanoid_UpdateAttack_AttackSpeedDtPatch
	{
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
		[HarmonyPrefix]
		private static void Prefix(Humanoid __instance, ref float dt)
		{
			try
			{
				EnsureAttackInit();
				if ((Object)(object)__instance == (Object)null)
				{
					return;
				}
				HumanoidState attackState = GetAttackState(__instance);
				if (attackState.ActiveAttackDepth > 0)
				{
					float activeAttackMul = attackState.ActiveAttackMul;
					if (!(activeAttackMul <= 0f) && !float.IsNaN(activeAttackMul) && !float.IsInfinity(activeAttackMul))
					{
						dt *= activeAttackMul;
					}
				}
			}
			catch (Exception ex)
			{
				LogError("Exception in Humanoid_UpdateAttack_AttackSpeedDtPatch: " + ex);
			}
		}
	}

	[HarmonyPatch(typeof(Humanoid), "CustomFixedUpdate")]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
	public static class Humanoid_CustomFixedUpdate_AttackSpeedPatch
	{
		[HarmonyPostfix]
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
		private static void Postfix(Humanoid __instance, float fixedDeltaTime)
		{
			EnsureAttackInit();
			HumanoidState attackState = GetAttackState(__instance);
			bool flag = ((Character)__instance).InAttack();
			if (flag)
			{
				if (attackState.HasDesiredSpeed)
				{
					ApplyAnimSpeed(__instance, attackState, attackState.DesiredSpeed);
				}
				else
				{
					ApplyAnimSpeed(__instance, attackState, 1f);
				}
			}
			else if (attackState.WasInAttack)
			{
				ApplyAnimSpeed(__instance, attackState, 1f);
				attackState.HasDesiredSpeed = false;
				attackState.DesiredSpeed = 1f;
			}
			attackState.WasInAttack = flag;
		}
	}

	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
	[HarmonyPatch(typeof(Character), "RPC_Stagger")]
	public static class Character_RPC_Stagger_AttackSpeedResetPatch
	{
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
		[HarmonyPostfix]
		private static void Postfix(Character __instance, long sender, Vector3 forceDirection)
		{
			try
			{
				EnsureAttackInit();
				Humanoid val = (Humanoid)(object)((__instance is Humanoid) ? __instance : null);
				if (!((Object)(object)val == (Object)null))
				{
					ResetForHumanoid(val);
				}
			}
			catch (Exception)
			{
			}
		}
	}

	[HarmonyPatch(typeof(Character), "OnDeath")]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
	public static class Character_OnDeath_AttackSpeedResetPatch
	{
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
		[HarmonyPostfix]
		private static void Postfix(Character __instance)
		{
			try
			{
				EnsureAttackInit();
				Humanoid val = (Humanoid)(object)((__instance is Humanoid) ? __instance : null);
				if (!((Object)(object)val == (Object)null))
				{
					ResetForHumanoid(val);
				}
			}
			catch (Exception)
			{
			}
		}
	}

	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
	[HarmonyPatch(typeof(Character), "FreezeFrame")]
	public static class Character_FreezeFrame_AttackSpeedScalePatch
	{
		[HarmonyPrefix]
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
		private static void Prefix(Character __instance, ref float duration)
		{
			try
			{
				EnsureAttackInit();
				if ((Object)(object)__instance == (Object)null || Mathf.Abs(duration - 0.15f) > 0.01f)
				{
					return;
				}
				Humanoid val = (Humanoid)(object)((__instance is Humanoid) ? __instance : null);
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				HumanoidState attackState = GetAttackState(val);
				if (!attackState.HasDesiredSpeed)
				{
					return;
				}
				float desiredSpeed = attackState.DesiredSpeed;
				if (!(desiredSpeed <= 1.001f) && !float.IsNaN(desiredSpeed) && !float.IsInfinity(desiredSpeed))
				{
					float num = duration / desiredSpeed;
					if (num < 0.03f)
					{
						num = 0.03f;
					}
					DLogAttackSpeed($"FreezeFrame scale: {duration:F3} -> {num:F3} (mul={desiredSpeed:F3})");
					duration = num;
				}
			}
			catch (Exception ex)
			{
				LogError("Exception in Character_FreezeFrame_AttackSpeedScalePatch: " + ex);
			}
		}
	}

	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
	[HarmonyPatch(typeof(CharacterAnimEvent), "UpdateFreezeFrame")]
	public static class CharacterAnimEvent_UpdateFreezeFrame_ReapplySpeedPatch
	{
		[HarmonyPostfix]
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
		private static void Postfix(CharacterAnimEvent __instance, float dt)
		{
			try
			{
				EnsureAttackInit();
				if ((Object)(object)__instance == (Object)null)
				{
					return;
				}
				Character componentInParent = ((Component)__instance).GetComponentInParent<Character>();
				Humanoid val = (Humanoid)(object)((componentInParent is Humanoid) ? componentInParent : null);
				if (!((Object)(object)val == (Object)null))
				{
					HumanoidState attackState = GetAttackState(val);
					if (attackState.HasDesiredSpeed && (attackState.ActiveAttackDepth > 0 || ((Character)val).InAttack()))
					{
						ApplyAnimSpeed(val, attackState, attackState.DesiredSpeed);
					}
					else
					{
						ApplyAnimSpeed(val, attackState, 1f);
					}
				}
			}
			catch (Exception ex)
			{
				LogError("Exception in CharacterAnimEvent_UpdateFreezeFrame_ReapplySpeedPatch: " + ex);
			}
		}
	}

	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
	[HarmonyPatch(typeof(SEMan), "AddStatusEffect", new Type[]
	{
		typeof(int),
		typeof(bool),
		typeof(int),
		typeof(float)
	})]
	public static class SEMan_AddStatusEffect_ByHash_WetImmunePatch
	{
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
		[HarmonyPrefix]
		private static bool Prefix(SEMan __instance, int nameHash, bool resetTime, int itemLevel, float skillLevel)
		{
			try
			{
				EnsureWetInit();
				if (nameHash != SEMan.s_statusEffectWet)
				{
					return true;
				}
				Character val = null;
				try
				{
					val = _semanCharacterRef.Invoke(__instance);
				}
				catch (Exception)
				{
					val = null;
				}
				if ((Object)(object)val != (Object)null && HasWetImmune(val))
				{
					DLogWet("Blocked Wet (AddStatusEffect by hash) due to WetImmune");
					return false;
				}
			}
			catch (Exception ex2)
			{
				LogError("Exception in SEMan_AddStatusEffect_ByHash_WetImmunePatch: " + ex2);
			}
			return true;
		}
	}

	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
	[HarmonyPatch(typeof(SEMan), "AddStatusEffect", new Type[]
	{
		typeof(StatusEffect),
		typeof(bool),
		typeof(int),
		typeof(float)
	})]
	public static class SEMan_AddStatusEffect_BySE_WetImmunePatch
	{
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
		[HarmonyPrefix]
		private static bool Prefix(SEMan __instance, StatusEffect statusEffect, bool resetTime, int itemLevel, float skillLevel, ref StatusEffect __result)
		{
			try
			{
				if ((Object)(object)statusEffect == (Object)null)
				{
					return true;
				}
				if (statusEffect.NameHash() != SEMan.s_statusEffectWet)
				{
					return true;
				}
				Character character = statusEffect.m_character;
				if ((Object)(object)character != (Object)null && HasWetImmune(character))
				{
					DLogWet("Blocked Wet (AddStatusEffect by SE) due to WetImmune");
					__result = null;
					return false;
				}
			}
			catch (Exception ex)
			{
				LogError("Exception in SEMan_AddStatusEffect_BySE_WetImmunePatch: " + ex);
			}
			return true;
		}
	}

	public static bool DEBUG = false;

	public static readonly List<ExtraStatEntry> ExtraStatsConfig = new List<ExtraStatEntry>
	{
		new ExtraStatEntry("ArmorInspirationTrinketPlainsDO", ExtraStatType.Eitr, 10f, ExtraSourceType.ItemDrop),
		new ExtraStatEntry("ArmorInspirationTrinketMistlandsDO", ExtraStatType.Eitr, 10f, ExtraSourceType.ItemDrop),
		new ExtraStatEntry("ArmorInspirationTrinketAshlandsDO", ExtraStatType.Eitr, 10f, ExtraSourceType.ItemDrop),
		new ExtraStatEntry("ArmorMushroomcallerLegsDO", ExtraStatType.Eitr, 5f, ExtraSourceType.ItemDrop),
		new ExtraStatEntry("ArmorTotemcallerLegsDO", ExtraStatType.Health, 5f, ExtraSourceType.ItemDrop),
		new ExtraStatEntry("ArmorDeathcallerHelmetDO", ExtraStatType.Eitr, 10f, ExtraSourceType.ItemDrop),
		new ExtraStatEntry("ArmorFrostcallerChestDO", ExtraStatType.Eitr, 15f, ExtraSourceType.ItemDrop),
		new ExtraStatEntry("ArmorFirecallerLegsDO", ExtraStatType.Eitr, 20f, ExtraSourceType.ItemDrop),
		new ExtraStatEntry("ArmorStonecallerLegsDO", ExtraStatType.Eitr, 20f, ExtraSourceType.ItemDrop),
		new ExtraStatEntry("ArmorWindcallerHelmetDO", ExtraStatType.Eitr, 25f, ExtraSourceType.ItemDrop),
		new ExtraStatEntry("ArmorLightcallerHelmetDO", ExtraStatType.Eitr, 25f, ExtraSourceType.ItemDrop),
		new ExtraStatEntry("ArmorStormcallerChestDO", ExtraStatType.Eitr, 30f, ExtraSourceType.ItemDrop),
		new ExtraStatEntry("ArmorBloodcallerChestDO", ExtraStatType.Health, 20f, ExtraSourceType.ItemDrop),
		new ExtraStatEntry("ArmorFrostcallerCapeDO", ExtraStatType.Eitr, 10f, ExtraSourceType.ItemDrop),
		new ExtraStatEntry("ArmorWindcallerCapeDO", ExtraStatType.Stamina, 20f, ExtraSourceType.ItemDrop),
		new ExtraStatEntry("ArmorBloodcallerCapeDO", ExtraStatType.Health, 50f, ExtraSourceType.ItemDrop),
		new ExtraStatEntry("SE_MushroomcallerBelt_DO", ExtraStatType.Eitr, 10f, ExtraSourceType.StatusEffect),
		new ExtraStatEntry("SE_DeathcallerBelt_DO", ExtraStatType.Eitr, 15f, ExtraSourceType.StatusEffect),
		new ExtraStatEntry("SE_FrostcallerBelt_DO", ExtraStatType.Eitr, 15f, ExtraSourceType.StatusEffect),
		new ExtraStatEntry("SE_FirecallerBelt_DO", ExtraStatType.Eitr, 20f, ExtraSourceType.StatusEffect),
		new ExtraStatEntry("SE_StonecallerBelt_DO", ExtraStatType.Eitr, 20f, ExtraSourceType.StatusEffect),
		new ExtraStatEntry("SE_LightcallerBelt_DO", ExtraStatType.Eitr, 20f, ExtraSourceType.StatusEffect),
		new ExtraStatEntry("SE_StormcallerBelt_DO", ExtraStatType.Eitr, 25f, ExtraSourceType.StatusEffect),
		new ExtraStatEntry("SE_TotemcallerBelt_DO", ExtraStatType.Health, 10f, ExtraSourceType.StatusEffect),
		new ExtraStatEntry("SE_WindcallerBelt_DO", ExtraStatType.Stamina, 15f, ExtraSourceType.StatusEffect),
		new ExtraStatEntry("SE_BloodBuff_DO", ExtraStatType.Health, 50f, ExtraSourceType.StatusEffect)
	};

	private static readonly ConditionalWeakTable<Humanoid, HumanoidState> _attackState = new ConditionalWeakTable<Humanoid, HumanoidState>();

	private static FieldRef<Character, ZSyncAnimation> _zanimRef;

	private static bool _attackInit;

	private const float HitFreeze_Default = 0.15f;

	private const float HitFreeze_Epsilon = 0.01f;

	private const float HitFreeze_Min = 0.03f;

	private static FieldRef<SEMan, Character> _semanCharacterRef;

	private static bool _wetInit;

	private static void LogInfo(string msg)
	{
	}

	private static void LogError(string msg)
	{
	}

	private static void DLogAttackSpeed(string msg)
	{
	}

	private static void DLogWet(string msg)
	{
	}

	private static void DLogTooltip(string msg)
	{
	}

	private static void DLogFood(string msg)
	{
	}

	private static void GetItemDropBonusesForPrefab(string prefabName, out float extraHp, out float extraStamina, out float extraEitr, out float extraAttackSpeedPercent, out float displayAttackSpeedPercent, out bool wetImmune)
	{
		extraHp = 0f;
		extraStamina = 0f;
		extraEitr = 0f;
		extraAttackSpeedPercent = 0f;
		displayAttackSpeedPercent = 0f;
		wetImmune = false;
		if (string.IsNullOrEmpty(prefabName))
		{
			return;
		}
		for (int i = 0; i < ExtraStatsConfig.Count; i++)
		{
			ExtraStatEntry extraStatEntry = ExtraStatsConfig[i];
			if (extraStatEntry.SourceType == ExtraSourceType.ItemDrop && string.Equals(prefabName, extraStatEntry.PrefabName, StringComparison.OrdinalIgnoreCase))
			{
				switch (extraStatEntry.StatType)
				{
				case ExtraStatType.Health:
					extraHp += extraStatEntry.Value;
					break;
				case ExtraStatType.Stamina:
					extraStamina += extraStatEntry.Value;
					break;
				case ExtraStatType.Eitr:
					extraEitr += extraStatEntry.Value;
					break;
				case ExtraStatType.AttackSpeed:
					extraAttackSpeedPercent += extraStatEntry.Value;
					displayAttackSpeedPercent += (extraStatEntry.DisplayValue.HasValue ? extraStatEntry.DisplayValue.Value : extraStatEntry.Value);
					break;
				case ExtraStatType.WetImmune:
					wetImmune = true;
					break;
				}
			}
		}
	}

	private static void GetItemDropBonusesForPrefab(string prefabName, out float extraHp, out float extraStamina, out float extraEitr, out float extraAttackSpeedPercent, out bool wetImmune)
	{
		GetItemDropBonusesForPrefab(prefabName, out extraHp, out extraStamina, out extraEitr, out extraAttackSpeedPercent, out var _, out wetImmune);
	}

	private static void GetStatusEffectBonuses(string seRawName, out float extraHp, out float extraStamina, out float extraEitr, out float extraAttackSpeedPercent, out float displayAttackSpeedPercent, out bool wetImmune)
	{
		extraHp = 0f;
		extraStamina = 0f;
		extraEitr = 0f;
		extraAttackSpeedPercent = 0f;
		displayAttackSpeedPercent = 0f;
		wetImmune = false;
		if (string.IsNullOrEmpty(seRawName))
		{
			return;
		}
		string prefabName = Utils.GetPrefabName(seRawName);
		for (int i = 0; i < ExtraStatsConfig.Count; i++)
		{
			ExtraStatEntry extraStatEntry = ExtraStatsConfig[i];
			if (extraStatEntry.SourceType == ExtraSourceType.StatusEffect && string.Equals(prefabName, extraStatEntry.PrefabName, StringComparison.OrdinalIgnoreCase))
			{
				switch (extraStatEntry.StatType)
				{
				case ExtraStatType.Health:
					extraHp += extraStatEntry.Value;
					break;
				case ExtraStatType.Stamina:
					extraStamina += extraStatEntry.Value;
					break;
				case ExtraStatType.Eitr:
					extraEitr += extraStatEntry.Value;
					break;
				case ExtraStatType.AttackSpeed:
					extraAttackSpeedPercent += extraStatEntry.Value;
					displayAttackSpeedPercent += (extraStatEntry.DisplayValue.HasValue ? extraStatEntry.DisplayValue.Value : extraStatEntry.Value);
					break;
				case ExtraStatType.WetImmune:
					wetImmune = true;
					break;
				}
			}
		}
	}

	private static void GetStatusEffectBonuses(string seRawName, out float extraHp, out float extraStamina, out float extraEitr, out float extraAttackSpeedPercent, out bool wetImmune)
	{
		GetStatusEffectBonuses(seRawName, out extraHp, out extraStamina, out extraEitr, out extraAttackSpeedPercent, out var _, out wetImmune);
	}

	private static string BuildExtraStatsTooltipBlock(float extraHp, float extraStamina, float extraEitr, float displayAttackSpeedPercent, bool wetImmune)
	{
		if (extraHp == 0f && extraStamina == 0f && extraEitr == 0f && displayAttackSpeedPercent == 0f && !wetImmune)
		{
			return string.Empty;
		}
		StringBuilder stringBuilder = new StringBuilder();
		string text = "$extrastats_health_DO";
		string text2 = "$extrastats_stamina_DO";
		string text3 = "$extrastats_eitr_DO";
		string text4 = "$extrastats_attackspeed_DO";
		string text5 = "$extrastats_immune_DO";
		string text6 = "$extrastats_wet_DO";
		if (Localization.instance != null)
		{
			text = Localization.instance.Localize(text);
			text2 = Localization.instance.Localize(text2);
			text3 = Localization.instance.Localize(text3);
			text4 = Localization.instance.Localize(text4);
			text5 = Localization.instance.Localize(text5);
			text6 = Localization.instance.Localize(text6);
		}
		if (extraHp != 0f)
		{
			string arg = ((extraHp >= 0f) ? "+" : "");
			stringBuilder.Append($"\n{text}: <color=#f27979>{arg}{extraHp:F0}</color>");
		}
		if (extraStamina != 0f)
		{
			string arg2 = ((extraStamina >= 0f) ? "+" : "");
			stringBuilder.Append($"\n{text2}: <color=#ffff80>{arg2}{extraStamina:F0}</color>");
		}
		if (extraEitr != 0f)
		{
			string arg3 = ((extraEitr >= 0f) ? "+" : "");
			stringBuilder.Append($"\n{text3}: <color=#8686ee>{arg3}{extraEitr:F0}</color>");
		}
		if (displayAttackSpeedPercent != 0f)
		{
			int num = Mathf.RoundToInt(displayAttackSpeedPercent);
			string arg4 = ((num >= 0) ? "+" : "");
			stringBuilder.Append($"\n{text4}: <color=orange>{arg4}{num}%</color>");
		}
		if (wetImmune)
		{
			stringBuilder.Append("\n" + text5 + ": <color=orange>" + text6 + "</color>");
		}
		return stringBuilder.ToString();
	}

	private static bool HasWetImmune(Character c)
	{
		if ((Object)(object)c == (Object)null)
		{
			return false;
		}
		try
		{
			Player val = (Player)(object)((c is Player) ? c : null);
			if ((Object)(object)val != (Object)null)
			{
				Inventory inventory = ((Humanoid)val).GetInventory();
				if (inventory != null)
				{
					List<ItemData> equippedItems = inventory.GetEquippedItems();
					for (int i = 0; i < equippedItems.Count; i++)
					{
						ItemData val2 = equippedItems[i];
						if (val2 != null && !((Object)(object)val2.m_dropPrefab == (Object)null))
						{
							string name = ((Object)val2.m_dropPrefab).name;
							GetItemDropBonusesForPrefab(name, out var _, out var _, out var _, out var _, out var _, out var wetImmune);
							if (wetImmune)
							{
								DLogWet("WetImmune from ItemDrop: " + name);
								return true;
							}
						}
					}
				}
			}
			if (c.m_seman != null && c.m_seman.m_statusEffects != null)
			{
				List<StatusEffect> statusEffects = c.m_seman.m_statusEffects;
				for (int j = 0; j < statusEffects.Count; j++)
				{
					StatusEffect val3 = statusEffects[j];
					if (!((Object)(object)val3 == (Object)null))
					{
						string name2 = ((Object)val3).name;
						GetStatusEffectBonuses(name2, out var _, out var _, out var _, out var _, out var _, out var wetImmune2);
						if (wetImmune2)
						{
							string prefabName = Utils.GetPrefabName(name2);
							DLogWet("WetImmune from StatusEffect: " + name2 + " (clean=" + prefabName + ")");
							return true;
						}
					}
				}
			}
		}
		catch (Exception ex)
		{
			LogError("Exception in HasWetImmune: " + ex);
		}
		return false;
	}

	private static void EnsureAttackInit()
	{
		if (!_attackInit)
		{
			_attackInit = true;
			_zanimRef = AccessTools.FieldRefAccess<Character, ZSyncAnimation>("m_zanim");
		}
	}

	private static HumanoidState GetAttackState(Humanoid h)
	{
		return _attackState.GetValue(h, (Humanoid _) => new HumanoidState());
	}

	private static void ApplyAnimSpeed(Humanoid h, HumanoidState state, float speed)
	{
		ZSyncAnimation val = null;
		try
		{
			val = _zanimRef.Invoke((Character)(object)h);
		}
		catch (Exception)
		{
			return;
		}
		if (!((Object)(object)val == (Object)null) && !Mathf.Approximately(state.LastAppliedSpeed, speed))
		{
			val.SetSpeed(speed);
			state.LastAppliedSpeed = speed;
		}
	}

	private static void ResetForHumanoid(Humanoid h)
	{
		if (!((Object)(object)h == (Object)null))
		{
			EnsureAttackInit();
			HumanoidState attackState = GetAttackState(h);
			ApplyAnimSpeed(h, attackState, 1f);
			attackState.HasDesiredSpeed = false;
			attackState.DesiredSpeed = 1f;
			attackState.WasInAttack = false;
			attackState.ActiveAttackDepth = 0;
			attackState.ActiveAttackMul = 1f;
		}
	}

	private static float ComputeTotalAttackSpeedPercentForHumanoid(Humanoid h)
	{
		float num = 0f;
		if ((Object)(object)h == (Object)null)
		{
			return 0f;
		}
		try
		{
			Player val = (Player)(object)((h is Player) ? h : null);
			if ((Object)(object)val != (Object)null)
			{
				Inventory inventory = ((Humanoid)val).GetInventory();
				if (inventory != null)
				{
					List<ItemData> equippedItems = inventory.GetEquippedItems();
					for (int i = 0; i < equippedItems.Count; i++)
					{
						ItemData val2 = equippedItems[i];
						if (val2 != null && !((Object)(object)val2.m_dropPrefab == (Object)null))
						{
							string name = ((Object)val2.m_dropPrefab).name;
							GetItemDropBonusesForPrefab(name, out var _, out var _, out var _, out var extraAttackSpeedPercent, out var _, out var _);
							if (extraAttackSpeedPercent != 0f)
							{
								num += extraAttackSpeedPercent;
								DLogAttackSpeed($"AttackSpeed from ItemDrop: {name} → {extraAttackSpeedPercent}%");
							}
						}
					}
				}
			}
			if (((Character)h).m_seman != null && ((Character)h).m_seman.m_statusEffects != null)
			{
				List<StatusEffect> statusEffects = ((Character)h).m_seman.m_statusEffects;
				for (int j = 0; j < statusEffects.Count; j++)
				{
					StatusEffect val3 = statusEffects[j];
					if (!((Object)(object)val3 == (Object)null))
					{
						string name2 = ((Object)val3).name;
						GetStatusEffectBonuses(name2, out var _, out var _, out var _, out var extraAttackSpeedPercent2, out var _, out var _);
						if (extraAttackSpeedPercent2 != 0f)
						{
							num += extraAttackSpeedPercent2;
							string prefabName = Utils.GetPrefabName(name2);
							DLogAttackSpeed($"AttackSpeed from StatusEffect: {name2} (clean={prefabName}) → {extraAttackSpeedPercent2}%");
						}
					}
				}
			}
		}
		catch (Exception ex)
		{
			LogError("Exception in ComputeTotalAttackSpeedPercentForHumanoid: " + ex);
		}
		return num;
	}

	private static void EnsureWetInit()
	{
		if (!_wetInit)
		{
			_wetInit = true;
			_semanCharacterRef = AccessTools.FieldRefAccess<SEMan, Character>("m_character");
		}
	}
}
[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
[HarmonyPatch]
[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
public static class LivingContainerSpawner
{
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
	private static class DevLog
	{
		public const bool Enabled = false;

		public const bool SpawnTimers = true;

		public const bool SpawnAttempts = true;

		public const bool Dedicated = true;

		public const bool Lifecycle = true;

		public const bool Perf = true;

		public const bool Watcher = true;

		public const bool WatcherVerbose = false;

		public const bool StateReset = true;
	}

	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	private class LivingContainerDef
	{
		public string Prefab;

		public Biome Biomes;

		public float CheckInterval;

		public float SpawnChance;

		public int MaxInWorld;

		public float MinDistance;

		public float MaxDistance;

		public float MinAltitude;

		public float MaxAltitude;

		public bool AllowInWater;

		public int MaxSpawnAttempts;

		public float DestroyDelay;

		public string VfxPrefab;

		public string PinSprite;

		public string PinText;

		public bool PinAnimate;

		public bool PinDoubleSize;
	}

	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
	private struct ItemsCacheEntry
	{
		public int ItemsLen;

		public int QuickHash;

		public bool IsEmpty;

		public int DecodedCount;

		public float LastTouchTime;
	}

	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
	private struct PrefabContainerTuning
	{
		public int Width;

		public int Height;

		public int LootMin;

		public int LootMax;

		public bool Equals(PrefabContainerTuning other)
		{
			if (Width == other.Width && Height == other.Height && LootMin == other.LootMin)
			{
				return LootMax == other.LootMax;
			}
			return false;
		}
	}

	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	private class LivingContainerRegistryComponent : MonoBehaviour
	{
		private ZNetView _nview;

		private ZDOID _uid;

		private string _prefab;

		private void Awake()
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				_nview = ((Component)this).GetComponent<ZNetView>();
				if ((Object)(object)_nview == (Object)null || !_nview.IsValid())
				{
					return;
				}
				_prefab = Utils.GetPrefabName(((Object)((Component)this).gameObject).name);
				BuildDefCache();
				if (DefByPrefab.ContainsKey(_prefab))
				{
					ZDO val = null;
					try
					{
						val = _nview.GetZDO();
					}
					catch
					{
					}
					if (val != null)
					{
						_uid = val.m_uid;
						RegisterLoadedRiko(_uid, _nview, _prefab);
					}
				}
			}
			catch
			{
			}
		}

		private void OnDestroy()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (_uid != default(ZDOID))
				{
					UnregisterLoadedRiko(_uid);
				}
			}
			catch
			{
			}
		}
	}

	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
	private enum GroundFail
	{
		None,
		WorldGenNoHeight,
		RaycastNoHit,
		WrongBiome,
		InWater,
		WaterTooDeep,
		OceanDepth,
		Lava,
		Altitude,
		Overlap,
		MistlandsBlocked
	}

	[HarmonyPatch(typeof(InventoryGui), "Hide")]
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	private static class InventoryGui_Hide_Patch
	{
		private static void Prefix(InventoryGui __instance, out Container __state)
		{
			__state = (((Object)(object)__instance != (Object)null) ? __instance.m_currentContainer : null);
		}

		private static void Postfix(Container __state)
		{
			if ((Object)(object)__state != (Object)null)
			{
				HandleContainerClosed(__state);
			}
		}
	}

	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	private class LivingContainerPinComponent : MonoBehaviour
	{
		public string PinSprite;

		public string PinText;

		public bool PinAnimate;

		public bool PinDoubleSize;

		private PinData _pin;

		private const float PinUpdateInterval_Seconds = 5f;

		private float _nextPinUpdateTime;

		private void Update()
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			if (!LivingContainerConfig.IsRikoEnabled())
			{
				if (_pin != null && (Object)(object)Minimap.instance != (Object)null)
				{
					Minimap.instance.RemovePin(_pin);
					_pin = null;
				}
				Object.Destroy((Object)(object)this);
				return;
			}
			float time = Time.time;
			if (_pin != null)
			{
				if (!(time < _nextPinUpdateTime))
				{
					_nextPinUpdateTime = time + 5f;
					_pin.m_pos = ((Component)this).transform.position;
				}
			}
			else
			{
				TryCreatePin();
			}
		}

		private void TryCreatePin()
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			if (!string.IsNullOrEmpty(PinSprite) && !((Object)(object)Minimap.instance == (Object)null) && Magic_SupremacyPlugin.PinSprites != null && Magic_SupremacyPlugin.PinSprites.TryGetValue(PinSprite, out var value) && !((Object)(object)value == (Object)null))
			{
				PinData val = Minimap.instance.AddPin(((Component)this).transform.position, (PinType)8, PinText ?? "", false, false, 0L, default(PlatformUserID));
				val.m_icon = value;
				val.m_animate = PinAnimate;
				val.m_doubleSize = PinDoubleSize;
				val.m_save = false;
				_pin = val;
				_nextPinUpdateTime = Time.time + 5f;
			}
		}

		private void OnDestroy()
		{
			if (_pin != null && (Object)(object)Minimap.instance != (Object)null)
			{
				Minimap.instance.RemovePin(_pin);
			}
		}
	}

	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
	private class RikoSpawnStabilizer : MonoBehaviour
	{
		private bool _started;

		public void Init()
		{
			if (!_started)
			{
				_started = true;
				((MonoBehaviour)this).StartCoroutine(StabilizeRoutine());
			}
		}

		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
		private IEnumerator StabilizeRoutine()
		{
			StabilizeOnce(((Component)this).gameObject);
			yield return null;
			StabilizeOnce(((Component)this).gameObject);
			yield return (object)new WaitForSeconds(0.35f);
			StabilizeOnce(((Component)this).gameObject);
		}
	}

	private static readonly LivingContainerDef[] Defs = new LivingContainerDef[6]
	{
		new LivingContainerDef
		{
			Prefab = "EncounterCreatureRikoBlackforestDO",
			Biomes = (Biome)8,
			CheckInterval = 360f,
			SpawnChance = 0.3f,
			MaxInWorld = 3,
			MinDistance = 18f,
			MaxDistance = 36f,
			MinAltitude = 0f,
			MaxAltitude = 2000f,
			AllowInWater = false,
			MaxSpawnAttempts = 15,
			DestroyDelay = 1f,
			VfxPrefab = "fx_riko_disappear_DO",
			PinSprite = "PinRikoDO",
			PinText = "",
			PinAnimate = false,
			PinDoubleSize = true
		},
		new LivingContainerDef
		{
			Prefab = "EncounterCreatureRikoSwampDO",
			Biomes = (Biome)2,
			CheckInterval = 360f,
			SpawnChance = 0.3f,
			MaxInWorld = 3,
			MinDistance = 18f,
			MaxDistance = 36f,
			MinAltitude = -1f,
			MaxAltitude = 2000f,
			AllowInWater = false,
			MaxSpawnAttempts = 18,
			DestroyDelay = 1f,
			VfxPrefab = "fx_riko_disappear_DO",
			PinSprite = "PinRikoDO",
			PinText = "",
			PinAnimate = false,
			PinDoubleSize = true
		},
		new LivingContainerDef
		{
			Prefab = "EncounterCreatureRikoMountainDO",
			Biomes = (Biome)4,
			CheckInterval = 360f,
			SpawnChance = 0.3f,
			MaxInWorld = 3,
			MinDistance = 18f,
			MaxDistance = 36f,
			MinAltitude = 10f,
			MaxAltitude = 2000f,
			AllowInWater = false,
			MaxSpawnAttempts = 15,
			DestroyDelay = 1f,
			VfxPrefab = "fx_riko_disappear_DO",
			PinSprite = "PinRikoDO",
			PinText = "",
			PinAnimate = false,
			PinDoubleSize = true
		},
		new LivingContainerDef
		{
			Prefab = "EncounterCreatureRikoPlainsDO",
			Biomes = (Biome)16,
			CheckInterval = 360f,
			SpawnChance = 0.3f,
			MaxInWorld = 3,
			MinDistance = 18f,
			MaxDistance = 36f,
			MinAltitude = 0f,
			MaxAltitude = 2000f,
			AllowInWater = false,
			MaxSpawnAttempts = 15,
			DestroyDelay = 1f,
			VfxPrefab = "fx_riko_disappear_DO",
			PinSprite = "PinRikoDO",
			PinText = "",
			PinAnimate = false,
			PinDoubleSize = true
		},
		new LivingContainerDef
		{
			Prefab = "EncounterCreatureRikoMistlandsDO",
			Biomes = (Biome)512,
			CheckInterval = 360f,
			SpawnChance = 0.3f,
			MaxInWorld = 3,
			MinDistance = 15f,
			MaxDistance = 40f,
			MinAltitude = 12f,
			MaxAltitude = 2000f,
			AllowInWater = false,
			MaxSpawnAttempts = 18,
			DestroyDelay = 1f,
			VfxPrefab = "fx_riko_disappear_DO",
			PinSprite = "PinRikoDO",
			PinText = "",
			PinAnimate = false,
			PinDoubleSize = true
		},
		new LivingContainerDef
		{
			Prefab = "EncounterCreatureRikoAshlandsDO",
			Biomes = (Biome)32,
			CheckInterval = 360f,
			SpawnChance = 0.3f,
			MaxInWorld = 3,
			MinDistance = 18f,
			MaxDistance = 36f,
			MinAltitude = 0f,
			MaxAltitude = 2000f,
			AllowInWater = false,
			MaxSpawnAttempts = 15,
			DestroyDelay = 1f,
			VfxPrefab = "fx_riko_disappear_DO",
			PinSprite = "PinRikoDO",
			PinText = "",
			PinAnimate = false,
			PinDoubleSize = true
		}
	};

	private const float Riko_SeenRadius_Meters = 120f;

	private const float Riko_SeenUpdateInterval_Seconds = 12f;

	private const float Riko_TTL_Minutes = 20f;

	private const float Riko_Grace_Minutes = 2f;

	private const float Riko_TtlScanInterval_Seconds = 45f;

	private const float Riko_DestroyScanInterval_Seconds = 20f;

	private const float Riko_LoadedDestroyCheckInterval_Seconds = 0.2f;

	private const float Riko_EmptyWatcherInterval_Seconds = 30f;

	private const float ConfigRefreshInterval_Seconds = 5f;

	private const int OriginMaxAttempts = 3;

	private const int OriginPickGuard = 16;

	private const int MaxCatchupChecksPerTick_PerDef = 2;

	private const float WorldCountRescanInterval_Seconds = 90f;

	private const float ServerStartupGrace_Seconds = 10f;

	private const float MaxAllowedWaterDepth_Center = 0.08f;

	private const float MaxAllowedWaterDepth_Side = 0.12f;

	private const float DryAreaProbeRadius = 0.9f;

	private const int DryAreaAllowedWetSideSamples = 1;

	private const float MistlandsHeadroomHeight = 2.2f;

	private const float MistlandsHeadroomRadius = 0.45f;

	private const float MistlandsCeilingCheckStart = 0.15f;

	private const float DedNoGroundLogInterval_Seconds = 15f;

	private const string ZdoKey_Killed = "MS_Riko_Killed";

	private const string ZdoKey_SpawnTime = "MS_Riko_SpawnTime";

	private const string ZdoKey_LastSeenTime = "MS_Riko_LastSeenTime";

	private const string ZdoKey_DestroyAt = "MS_Riko_DestroyAt";

	private const string ZdoKey_VfxPlayed = "MS_Riko_VfxPlayed";

	private const string ZdoKey_FinalDestroyCounted = "MS_Riko_FinalDestroyCounted";

	private static readonly Dictionary<string, LivingContainerDef> DefByPrefab = new Dictionary<string, LivingContainerDef>(StringComparer.OrdinalIgnoreCase);

	private static readonly Dictionary<string, int> WorldCounts = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);

	private static float[] WorldChecks;

	private static float LastWorldUpdate;

	private static float NextSeenUpdateTime;

	private static float NextDestroyScanTime;

	private static float NextLoadedDestroyCheckTime;

	private static float NextTtlScanTime;

	private static float NextConfigRefreshTime;

	private static float NextWorldCountRescanTime;

	private static readonly Dictionary<string, float> NextAuthoritativeCountCheckTime = new Dictionary<string, float>(StringComparer.OrdinalIgnoreCase);

	private const float AuthoritativeCountRefreshInterval_Seconds = 20f;

	private static bool WorldCountCacheInitialized;

	private static readonly List<Vector3> OriginPositions = new List<Vector3>(32);

	private static readonly FieldInfo ZNetPeer_m_refPos_Field = AccessTools.Field(typeof(ZNetPeer), "m_refPos");

	private static readonly Dictionary<ZDOID, ZNetView> LoadedRikos = new Dictionary<ZDOID, ZNetView>(256);

	private static int LoadedRegistryInvalidSweeps;

	private static List<ZDOID> _registrySweepKeys;

	private static bool PurgeInProgress;

	private static int PurgePrefabIndex;

	private static int PurgeSectorIndex;

	private static readonly List<ZDO> PurgeZdos = new List<ZDO>(256);

	private static float ServerWorldEnterTime = -1f;

	private static bool ServerGraceLogged;

	private static float _dedNextNoGroundLogTime;

	private static int _dedLastPlayers = -999;

	private static int _dedLastPeers = -999;

	private static int _dedLastOriginPos = -999;

	private static float _dedNextHeartbeatTime;

	private static bool _emptyWatcherInProgress;

	private static int _emptyWatcherPrefabIndex;

	private static int _emptyWatcherSectorIndex;

	private static readonly List<ZDO> _emptyWatcherZdos = new List<ZDO>(256);

	private static float _emptyWatcherNextRunTime;

	private static int _hashInUse;

	private static int _hashItems;

	private static readonly Dictionary<ZDOID, ItemsCacheEntry> _itemsCache = new Dictionary<ZDOID, ItemsCacheEntry>(512);

	private static float _itemsCacheNextCleanupTime;

	private const float ItemsCacheCleanupInterval_Seconds = 60f;

	private const float ItemsCacheKeepSeconds = 600f;

	private const int ItemsCacheMaxSize = 4096;

	private static List<ZDOID> _itemsCacheKeysTmp;

	private static readonly Dictionary<string, PrefabContainerTuning> AppliedPrefabTuning = new Dictionary<string, PrefabContainerTuning>(StringComparer.OrdinalIgnoreCase);

	private static readonly int SolidMask = LayerMask.GetMask(new string[5] { "terrain", "static_solid", "Default", "piece", "vehicle" });

	private static readonly Vector2[] DryAreaProbeOffsets = (Vector2[])(object)new Vector2[5]
	{
		new Vector2(0f, 0f),
		new Vector2(1f, 0f),
		new Vector2(-1f, 0f),
		new Vector2(0f, 1f),
		new Vector2(0f, -1f)
	};

	private static void Log(string msg)
	{
	}

	private static void LogTimers(string msg)
	{
	}

	private static void LogSpawn(string msg)
	{
	}

	private static void LogDed(string msg)
	{
	}

	private static void LogLife(string msg)
	{
	}

	private static void LogPerf(string msg)
	{
	}

	private static void LogWatcher(string msg)
	{
	}

	private static void LogWatcherVerbose(string msg)
	{
	}

	private static void LogReset(string msg)
	{
	}

	private static void RegisterLoadedRiko(ZDOID uid, ZNetView nv, string prefab)
	{
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)nv == (Object)null))
		{
			LoadedRikos[uid] = nv;
			LogPerf($"registry ADD prefab={prefab} uid={uid} loaded={LoadedRikos.Count}");
		}
	}

	private static void UnregisterLoadedRiko(ZDOID uid)
	{
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		if (LoadedRikos.Remove(uid))
		{
			LogPerf($"registry REMOVE uid={uid} loaded={LoadedRikos.Count}");
		}
	}

	private static void EnsureRegistryComponent(GameObject go)
	{
		if (!((Object)(object)go == (Object)null) && !((Object)(object)go.GetComponent<LivingContainerRegistryComponent>() != (Object)null))
		{
			go.AddComponent<LivingContainerRegistryComponent>();
		}
	}

	[HarmonyPostfix]
	[HarmonyPatch(typeof(ZNet), "Awake")]
	private static void ZNet_Awake_Postfix()
	{
		try
		{
			if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer())
			{
				ResetRuntimeState_Server("ZNet.Awake");
			}
		}
		catch
		{
		}
	}

	private static void ResetRuntimeState_Server(string reason)
	{
		WorldChecks = null;
		LastWorldUpdate = 0f;
		WorldCounts.Clear();
		WorldCountCacheInitialized = false;
		NextWorldCountRescanTime = 0f;
		NextAuthoritativeCountCheckTime.Clear();
		LoadedRikos.Clear();
		LoadedRegistryInvalidSweeps = 0;
		NextSeenUpdateTime = 0f;
		NextDestroyScanTime = 0f;
		NextLoadedDestroyCheckTime = 0f;
		NextTtlScanTime = 0f;
		NextConfigRefreshTime = 0f;
		PurgeInProgress = false;
		PurgePrefabIndex = 0;
		PurgeSectorIndex = 0;
		PurgeZdos.Clear();
		_emptyWatcherInProgress = false;
		_emptyWatcherPrefabIndex = 0;
		_emptyWatcherSectorIndex = 0;
		_emptyWatcherZdos.Clear();
		_emptyWatcherNextRunTime = 0f;
		_itemsCache.Clear();
		_itemsCacheNextCleanupTime = 0f;
		ServerWorldEnterTime = Time.time;
		ServerGraceLogged = false;
		OriginPositions.Clear();
		_dedNextNoGroundLogTime = 0f;
		_dedLastPlayers = -999;
		_dedLastPeers = -999;
		_dedLastOriginPos = -999;
		_dedNextHeartbeatTime = 0f;
		LogReset($"server RuntimeState RESET reason={reason} time={ServerWorldEnterTime:0.00} session={ZDOMan.GetSessionID()}");
	}

	[HarmonyPostfix]
	[HarmonyPatch(typeof(ZoneSystem), "Update")]
	private static void ZoneSystem_Update_Postfix()
	{
		if (!LivingContainerConfig.IsRikoEnabled() || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || (Object)(object)ZNetScene.instance == (Object)null || ZDOMan.instance == null || (Object)(object)ObjectDB.instance == (Object)null)
		{
			return;
		}
		if (ServerWorldEnterTime < 0f)
		{
			ServerWorldEnterTime = Time.time;
		}
		float num = Time.time - ServerWorldEnterTime;
		bool flag = num < 10f;
		if (flag && !ServerGraceLogged)
		{
			ServerGraceLogged = true;
			LogTimers($"server StartupGrace ACTIVE seconds={10f:0.0} sinceEnter={num:0.00}");
		}
		BuildDefCache();
		if (Time.time >= NextConfigRefreshTime)
		{
			RefreshDefsFromConfig();
			NextConfigRefreshTime = Time.time + 5f;
		}
		List<Player> allPlayers = Player.GetAllPlayers();
		BuildOriginPositions(allPlayers);
		LogDedicatedStateIfNeeded(allPlayers);
		UpdateLastSeenForLoadedRikos();
		ProcessLoadedDestroyDueFast();
		ProcessScheduledDestroyForLoadedRikos();
		TryRunEmptyWatcher_Server();
		TryPurgeExpiredOrKilledRikoZDOs();
		if (OriginPositions.Count == 0)
		{
			return;
		}
		float time = Time.time;
		if (LastWorldUpdate <= 0f)
		{
			LastWorldUpdate = time;
			EnsureWorldChecksInitialized();
			EnsureWorldCounts_Cached(initial: true);
			LogTimers($"server WorldTimers INIT sinceEnter={num:0.00} note=FirstWorldTick");
			return;
		}
		float num2 = time - LastWorldUpdate;
		if (num2 < 5f)
		{
			return;
		}
		LastWorldUpdate = time;
		EnsureWorldChecksInitialized();
		EnsureWorldCounts_Cached(initial: false);
		LogTimers($"server WorldTick sinceEnter={num:0.00} delta={num2:0.00} origins={OriginPositions.Count}");
		for (int i = 0; i < Defs.Length; i++)
		{
			LivingContainerDef livingContainerDef = Defs[i];
			if (livingContainerDef == null)
			{
				continue;
			}
			float num3 = WorldChecks[i];
			WorldChecks[i] -= num2;
			float num4 = WorldChecks[i];
			if (num3 > 0f && (num3 < 5f || num4 <= 0f))
			{
				LogTimers($"server WorldTimer prefab={livingContainerDef.Prefab} before={num3:0.00} after={num4:0.00} delta={num2:0.00} interval={livingContainerDef.CheckInterval:0.0} grace={flag}");
			}
			if (WorldChecks[i] > 0f)
			{
				continue;
			}
			if (flag)
			{
				WorldChecks[i] = Mathf.Max(1f, livingContainerDef.CheckInterval);
				LogTimers($"server WorldTimer BLOCKED_BY_GRACE prefab={livingContainerDef.Prefab} setNext={WorldChecks[i]:0.00}");
				continue;
			}
			int num5 = 0;
			float num6 = Mathf.Max(1f, livingContainerDef.CheckInterval);
			while (WorldChecks[i] <= 0f && num5 < 2)
			{
				TrySpawnWithFallbackOrigins(OriginPositions, livingContainerDef, num, num5);
				WorldChecks[i] += num6;
				num5++;
			}
			if (WorldChecks[i] <= 0f)
			{
				WorldChecks[i] = Mathf.Min(1f, num6);
				LogTimers($"server WorldTimer STILL_OVERDUE prefab={livingContainerDef.Prefab} cappedNext={WorldChecks[i]:0.00}");
			}
			else
			{
				LogTimers($"server WorldTimer ADVANCED prefab={livingContainerDef.Prefab} nextIn={WorldChecks[i]:0.00} catchupUsed={num5}");
			}
		}
	}

	private static void EnsureWorldChecksInitialized()
	{
		if (WorldChecks == null || WorldChecks.Length != Defs.Length)
		{
			WorldChecks = new float[Defs.Length];
			for (int i = 0; i < WorldChecks.Length; i++)
			{
				LivingContainerDef livingContainerDef = Defs[i];
				float num = ((livingContainerDef != null) ? Mathf.Max(1f, livingContainerDef.CheckInterval) : 60f);
				float num2 = Mathf.Min(30f, num * 0.1f);
				WorldChecks[i] = num + Random.Range(0f, num2);
			}
			LogTimers($"server WorldChecks CREATED count={WorldChecks.Length}");
		}
	}

	private static void BuildOriginPositions(List<Player> players)
	{
		//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00da: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
		//IL_0101: Unknown result type (might be due to invalid IL or missing references)
		//IL_0112: Unknown result type (might be due to invalid IL or missing references)
		//IL_0117: Unknown result type (might be due to invalid IL or missing references)
		//IL_0121: Unknown result type (might be due to invalid IL or missing references)
		//IL_0132: Unknown result type (might be due to invalid IL or missing references)
		//IL_0137: Unknown result type (might be due to invalid IL or missing references)
		//IL_0141: Unknown result type (might be due to invalid IL or missing references)
		//IL_0152: Unknown result type (might be due to invalid IL or missing references)
		//IL_0157: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_008c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0091: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
		OriginPositions.Clear();
		if (players != null && players.Count > 0)
		{
			for (int i = 0; i < players.Count; i++)
			{
				Player val = players[i];
				if (!((Object)(object)val == (Object)null))
				{
					AddOriginPosition(((Component)val).transform.position);
				}
			}
		}
		else
		{
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				return;
			}
			List<ZNetPeer> list = null;
			try
			{
				list = ZNet.instance.GetPeers();
			}
			catch
			{
			}
			if (list == null || list.Count == 0)
			{
				return;
			}
			for (int j = 0; j < list.Count; j++)
			{
				ZNetPeer val2 = list[j];
				if (val2 == null)
				{
					continue;
				}
				Vector3 val3 = Vector3.zero;
				try
				{
					if (ZNetPeer_m_refPos_Field != null)
					{
						object value = ZNetPeer_m_refPos_Field.GetValue(val2);
						if (value is Vector3)
						{
							Vector3 val4 = (Vector3)value;
							val3 = val4;
						}
					}
				}
				catch
				{
				}
				if (!(val3 == Vector3.zero))
				{
					AddOriginPosition(val3);
					AddOriginPosition(val3 + new Vector3(24f, 0f, 0f));
					AddOriginPosition(val3 + new Vector3(-24f, 0f, 0f));
					AddOriginPosition(val3 + new Vector3(0f, 0f, 24f));
					AddOriginPosition(val3 + new Vector3(0f, 0f, -24f));
				}
			}
		}
	}

	private static void AddOriginPosition(Vector3 pos)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		if (pos == Vector3.zero)
		{
			return;
		}
		for (int i = 0; i < OriginPositions.Count; i++)
		{
			Vector3 val = OriginPositions[i] - pos;
			if (((Vector3)(ref val)).sqrMagnitude < 1f)
			{
				return;
			}
		}
		OriginPositions.Add(pos);
	}

	private static void LogDedicatedStateIfNeeded(List<Player> players)
	{
	}

	private static bool SafeIsDedicated()
	{
		try
		{
			return (Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsDedicated();
		}
		catch
		{
			return false;
		}
	}

	private static bool TrySpawnWithFallbackOrigins(List<Vector3> origins, LivingContainerDef def, float sinceEnter, int catchup)
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
		//IL_0055: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_018d: Unknown result type (might be due to invalid IL or missing references)
		//IL_019c: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
		//IL_0103: Unknown result type (might be due to invalid IL or missing references)
		//IL_006e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0070: Unknown result type (might be due to invalid IL or missing references)
		//IL_0110: Unknown result type (might be due to invalid IL or missing references)
		//IL_011c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0128: Unknown result type (might be due to invalid IL or missing references)
		//IL_013e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0146: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_009e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
		if (origins == null || origins.Count == 0 || def == null)
		{
			return false;
		}
		int num = 0;
		int num2 = -1;
		int num3 = -1;
		int num4 = -1;
		for (int i = 0; i < 3; i++)
		{
			int num5 = -1;
			Vector3 val = Vector3.zero;
			int num6 = 0;
			while (num5 < 0 && num6 < 16)
			{
				num6++;
				int num7 = Random.Range(0, origins.Count);
				if (num7 != num2 && num7 != num3 && num7 != num4)
				{
					Vector3 val2 = origins[num7];
					if (!(val2 == Vector3.zero))
					{
						num5 = num7;
						val = val2;
					}
				}
			}
			if (num5 < 0)
			{
				for (int j = 0; j < origins.Count; j++)
				{
					if (j != num2 && j != num3 && j != num4)
					{
						Vector3 val3 = origins[j];
						if (!(val3 == Vector3.zero))
						{
							num5 = j;
							val = val3;
							break;
						}
					}
				}
			}
			if (num5 < 0)
			{
				return false;
			}
			switch (num)
			{
			case 0:
				num2 = num5;
				break;
			case 1:
				num3 = num5;
				break;
			case 2:
				num4 = num5;
				break;
			}
			num++;
			Biome biomeSafe = GetBiomeSafe(val);
			if ((int)biomeSafe != 0 && (biomeSafe & def.Biomes) == 0)
			{
				LogSpawn("server TrySpawn SKIP originBiomeMismatch " + $"originPos=({val.x:0.0},{val.y:0.0},{val.z:0.0}) " + $"originBiome={biomeSafe} needed={def.Biomes} prefab={def.Prefab} " + $"originAttempt={i + 1}/{3}");
				continue;
			}
			LogSpawn($"server TrySpawn CALL originPos=({val.x:0.0},{val.y:0.0},{val.z:0.0}) prefab={def.Prefab} sinceEnter={sinceEnter:0.00} catchup={catchup} originAttempt={i + 1}/{3}");
			if (TrySpawnAtPosition(val, def))
			{
				return true;
			}
		}
		return false;
	}

	private static bool TrySpawnAtPosition(Vector3 origin, LivingContainerDef def)
	{
		//IL_037d: Unknown result type (might be due to invalid IL or missing references)
		//IL_038c: Unknown result type (might be due to invalid IL or missing references)
		//IL_039b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
		//IL_0201: Unknown result type (might be due to invalid IL or missing references)
		//IL_0206: Unknown result type (might be due to invalid IL or missing references)
		//IL_0209: Unknown result type (might be due to invalid IL or missing references)
		//IL_020b: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
		if (def == null)
		{
			return false;
		}
		float value = Random.value;
		if (value > def.SpawnChance)
		{
			LogSpawn($"server TrySpawn FAIL chance prefab={def.Prefab} rnd={value:0.000} chance={def.SpawnChance:0.000}");
			return false;
		}
		int authoritativeAliveCountForPrefab = GetAuthoritativeAliveCountForPrefab(def.Prefab);
		if (authoritativeAliveCountForPrefab >= def.MaxInWorld)
		{
			LogSpawn($"server TrySpawn FAIL maxInWorld prefab={def.Prefab} count={authoritativeAliveCountForPrefab} max={def.MaxInWorld}");
			return false;
		}
		GameObject prefab = ZNetScene.instance.GetPrefab(def.Prefab);
		if ((Object)(object)prefab == (Object)null)
		{
			LogSpawn("server TrySpawn FAIL missingPrefab prefab=" + def.Prefab);
			return false;
		}
		ApplyContainerConfigToPrefab(def, prefab);
		int num = Mathf.Max(1, def.MaxSpawnAttempts);
		int num2 = 0;
		int num3 = 0;
		int num4 = 0;
		int num5 = 0;
		int num6 = 0;
		int num7 = 0;
		int num8 = 0;
		int num9 = 0;
		int num10 = 0;
		int num11 = 0;
		for (int i = 0; i < num; i++)
		{
			Vector3 val = PickPoint(origin, def.MinDistance, def.MaxDistance);
			if (!TryGetRikoSpawnPoint(val, def, out var spawnPos, out var fail))
			{
				switch (fail)
				{
				case GroundFail.WorldGenNoHeight:
				case GroundFail.RaycastNoHit:
					num2++;
					break;
				case GroundFail.WrongBiome:
					num3++;
					break;
				case GroundFail.InWater:
					num4++;
					break;
				case GroundFail.WaterTooDeep:
					num5++;
					break;
				case GroundFail.OceanDepth:
					num6++;
					break;
				case GroundFail.Lava:
					num7++;
					break;
				case GroundFail.Altitude:
					num8++;
					break;
				case GroundFail.Overlap:
					num9++;
					break;
				case GroundFail.MistlandsBlocked:
					num10++;
					break;
				}
				LogSpawn($"server TrySpawn attempt={i + 1} FAIL prefab={def.Prefab} fail={fail} candidate=({val.x:0.0},{val.y:0.0},{val.z:0.0})");
				continue;
			}
			Quaternion val2 = Quaternion.Euler(0f, Random.Range(0f, 360f), 0f);
			GameObject val3 = Object.Instantiate<GameObject>(prefab, spawnPos, val2);
			if ((Object)(object)val3 == (Object)null)
			{
				num11++;
				LogSpawn($"server TrySpawn attempt={i + 1} FAIL instantiateNull prefab={def.Prefab}");
				continue;
			}
			EnsureRegistryComponent(val3);
			AttachPinComponent(val3, def);
			Container component = val3.GetComponent<Container>();
			if ((Object)(object)component != (Object)null)
			{
				component.m_autoDestroyEmpty = false;
			}
			FixSpawnInsideGeometry(val3);
			ZNetView val4 = null;
			ZDO val5 = null;
			try
			{
				val4 = val3.GetComponent<ZNetView>();
				if ((Object)(object)val4 != (Object)null && val4.IsValid())
				{
					val5 = val4.GetZDO();
				}
			}
			catch
			{
			}
			if (val5 != null)
			{
				try
				{
					EnsureServerOwnership(val4, val5, "SpawnInitZdo");
					long nowSeconds = GetNowSeconds();
					val5.Set("MS_Riko_SpawnTime", nowSeconds);
					val5.Set("MS_Riko_LastSeenTime", nowSeconds);
					val5.Set("MS_Riko_Killed", 0);
					val5.Set("MS_Riko_DestroyAt", 0L);
					val5.Set("MS_Riko_VfxPlayed", 0);
					val5.Set("MS_Riko_FinalDestroyCounted", 0);
				}
				catch
				{
				}
			}
			WorldCounts[def.Prefab] = ((!WorldCounts.TryGetValue(def.Prefab, out var value2)) ? 1 : (value2 + 1));
			string text = ((val5 != null) ? ((object)(ZDOID)(ref val5.m_uid)).ToString() : "null");
			LogSpawn($"server TrySpawn SUCCESS prefab={def.Prefab} uid={text} pos=({spawnPos.x:0.0},{spawnPos.y:0.0},{spawnPos.z:0.0}) attempt={i + 1} worldCount={WorldCounts[def.Prefab]}");
			LogSpawn($"server TrySpawn SUMMARY prefab={def.Prefab} attempts={num} " + $"groundFail={num2} biomeFail={num3} waterFail={num4} deepWaterFail={num5} oceanFail={num6} lavaFail={num7} altitudeFail={num8} overlapFail={num9} mistBlockedFail={num10} instFail={num11}");
			return true;
		}
		LogSpawn($"server TrySpawn SUMMARY prefab={def.Prefab} attempts={num} " + $"groundFail={num2} biomeFail={num3} waterFail={num4} deepWaterFail={num5} oceanFail={num6} lavaFail={num7} altitudeFail={num8} overlapFail={num9} mistBlockedFail={num10} instFail={num11}");
		return false;
	}

	private static bool TryGetRikoSpawnPoint(Vector3 candidate, LivingContainerDef def, out Vector3 spawnPos, out GroundFail fail)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Invalid comparison between Unknown and I4
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0066: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_0086: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00da: Unknown result type (might be due to invalid IL or missing references)
		//IL_0106: Unknown result type (might be due to invalid IL or missing references)
		//IL_0110: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_0132: Unknown result type (might be due to invalid IL or missing references)
		//IL_0142: Unknown result type (might be due to invalid IL or missing references)
		//IL_0144: Unknown result type (might be due to invalid IL or missing references)
		//IL_014e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0153: Unknown result type (might be due to invalid IL or missing references)
		//IL_0158: Unknown result type (might be due to invalid IL or missing references)
		//IL_0123: Unknown result type (might be due to invalid IL or missing references)
		//IL_011a: Unknown result type (might be due to invalid IL or missing references)
		spawnPos = candidate;
		fail = GroundFail.None;
		if (!TryGetGroundPoint(candidate, out var groundPoint, out var fail2))
		{
			fail = fail2;
			return false;
		}
		Biome biomeSafe = GetBiomeSafe(groundPoint);
		if ((biomeSafe & def.Biomes) == 0)
		{
			fail = GroundFail.WrongBiome;
			return false;
		}
		bool flag = (biomeSafe & 2) > 0;
		Heightmap val = Heightmap.FindHeightmap(groundPoint);
		if ((Object)(object)val != (Object)null && val.GetOceanDepth(groundPoint) > 0.5f)
		{
			fail = GroundFail.OceanDepth;
			return false;
		}
		if ((def.Biomes & 0x20) != 0)
		{
			bool flag2 = IsAshlandsLavaByWorldGen(groundPoint);
			if (!flag2 && (Object)(object)val != (Object)null)
			{
				flag2 = val.IsLava(groundPoint, 0.4f);
			}
			if (flag2)
			{
				fail = GroundFail.Lava;
				return false;
			}
		}
		if (!def.AllowInWater && !flag && IsAreaTooWetForRiko(groundPoint, out var _, out var _))
		{
			fail = GroundFail.WaterTooDeep;
			return false;
		}
		if (groundPoint.y < def.MinAltitude || groundPoint.y > def.MaxAltitude)
		{
			fail = GroundFail.Altitude;
			return false;
		}
		Vector3 ground = groundPoint;
		if (SafeIsDedicated())
		{
			TryFindSolidBelow(groundPoint + Vector3.up * 1f, 8f, out ground);
		}
		if ((def.Biomes & 0x200) != 0 && (SafeIsDedicated() ? IsMistlandsSpawnSpaceBlocked(ground) : IsMistlandsSpawnSpaceBlocked_Local(ground)))
		{
			fail = GroundFail.MistlandsBlocked;
			return false;
		}
		if (IsBodyOverlapping(ground))
		{
			fail = GroundFail.Overlap;
			return false;
		}
		spawnPos = ground + Vector3.up * 0.03f;
		return true;
	}

	private static bool TryGetGroundPoint(Vector3 candidate, out Vector3 groundPoint, out GroundFail fail)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
		//IL_0103: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_007f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0089: Unknown result type (might be due to invalid IL or missing references)
		//IL_008e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0093: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_0056: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		//IL_00af: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_0072: Unknown result type (might be due to invalid IL or missing references)
		//IL_0077: Unknown result type (might be due to invalid IL or missing references)
		groundPoint = candidate;
		fail = GroundFail.None;
		if (SafeIsDedicated())
		{
			if (TryGetWorldGeneratorHeight(candidate.x, candidate.z, out var y))
			{
				groundPoint = new Vector3(candidate.x, y, candidate.z);
				RaycastHit val = default(RaycastHit);
				if (Physics.Raycast(candidate + Vector3.up * 200f, Vector3.down, ref val, 500f, SolidMask, (QueryTriggerInteraction)1))
				{
					groundPoint = ((RaycastHit)(ref val)).point;
				}
				return true;
			}
			RaycastHit val2 = default(RaycastHit);
			if (Physics.Raycast(candidate + Vector3.up * 200f, Vector3.down, ref val2, 500f, SolidMask, (QueryTriggerInteraction)1))
			{
				groundPoint = ((RaycastHit)(ref val2)).point;
				return true;
			}
			fail = GroundFail.WorldGenNoHeight;
			ThrottledNoGroundLog(candidate, fail);
			return false;
		}
		RaycastHit val3 = default(RaycastHit);
		if (!Physics.Raycast(candidate + Vector3.up * 200f, Vector3.down, ref val3, 500f, SolidMask, (QueryTriggerInteraction)1))
		{
			fail = GroundFail.RaycastNoHit;
			return false;
		}
		groundPoint = ((RaycastHit)(ref val3)).point;
		return true;
	}

	private static bool TryGetWorldGeneratorHeight(float x, float z, out float y)
	{
		y = 0f;
		try
		{
			if (WorldGenerator.instance == null)
			{
				return false;
			}
			Color val = default(Color);
			float height = WorldGenerator.instance.GetHeight(x, z, ref val);
			if (float.IsNaN(height) || float.IsInfinity(height))
			{
				return false;
			}
			y = height;
			return true;
		}
		catch
		{
			return false;
		}
	}

	private static Biome GetBiomeSafe(Vector3 pos)
	{
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			if (WorldGenerator.instance != null)
			{
				return WorldGenerator.instance.GetBiome(pos);
			}
		}
		catch
		{
		}
		try
		{
			return Heightmap.FindBiome(pos);
		}
		catch
		{
		}
		return (Biome)0;
	}

	private static bool IsAshlandsLavaByWorldGen(Vector3 point, float lavaValue = 0.4f)
	{
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Invalid comparison between Unknown and I4
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			if (WorldGenerator.instance == null)
			{
				return false;
			}
			if ((int)WorldGenerator.instance.GetBiome(point) != 32)
			{
				return false;
			}
			Color val = default(Color);
			WorldGenerator.instance.GetBiomeHeight((Biome)32, point.x, point.z, ref val, false);
			return val.a > lavaValue;
		}
		catch
		{
			return false;
		}
	}

	private static void ThrottledNoGroundLog(Vector3 candidate, GroundFail fail)
	{
	}

	private static bool IsAreaTooWetForRiko(Vector3 centerGround, out float centerDepth, out int wetSideSamples)
	{
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		centerDepth = 0f;
		wetSideSamples = 0;
		for (int i = 0; i < DryAreaProbeOffsets.Length; i++)
		{
			Vector2 val = DryAreaProbeOffsets[i] * 0.9f;
			float num = centerGround.x + val.x;
			float num2 = centerGround.z + val.y;
			if (!TryGetWorldGeneratorHeight(num, num2, out var y))
			{
				if (i == 0)
				{
					centerDepth = 999f;
				}
				return true;
			}
			if (!TryGetWaterSurfaceY(new Vector3(num, y, num2), out var waterY))
			{
				continue;
			}
			float num3 = waterY - y;
			if (i == 0)
			{
				centerDepth = num3;
				if (num3 > 0.08f)
				{
					return true;
				}
			}
			else if (num3 > 0.12f)
			{
				wetSideSamples++;
			}
		}
		return wetSideSamples > 1;
	}

	private static bool TryGetWaterSurfaceY(Vector3 point, out float waterY)
	{
		//IL_0056: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		waterY = 0f;
		List<WaterVolume> instances = WaterVolume.Instances;
		if (instances == null || instances.Count == 0)
		{
			return false;
		}
		WaterVolume val = null;
		float num = float.MaxValue;
		for (int i = 0; i < instances.Count; i++)
		{
			WaterVolume val2 = instances[i];
			if ((Object)(object)val2 == (Object)null)
			{
				continue;
			}
			Collider val3 = null;
			try
			{
				val3 = ((Component)val2).GetComponent<Collider>();
			}
			catch
			{
			}
			if ((Object)(object)val3 == (Object)null)
			{
				continue;
			}
			Vector3 val4 = val3.ClosestPoint(point) - point;
			float sqrMagnitude = ((Vector3)(ref val4)).sqrMagnitude;
			if (sqrMagnitude < num)
			{
				num = sqrMagnitude;
				val = val2;
				if (num <= 1E-06f)
				{
					break;
				}
			}
		}
		if ((Object)(object)val == (Object)null)
		{
			return false;
		}
		try
		{
			waterY = val.GetWaterSurface(point, 1f);
			return true;
		}
		catch
		{
			return false;
		}
	}

	private static bool IsMistlandsSpawnSpaceBlocked(Vector3 groundPoint)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0080: Unknown result type (might be due to invalid IL or missing references)
		//IL_0085: Unknown result type (might be due to invalid IL or missing references)
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00da: Unknown result type (might be due to invalid IL or missing references)
		//IL_00df: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
		Vector3 val = groundPoint + Vector3.up * 0.15f;
		Vector3 val2 = val + Vector3.up * 2.2f;
		if (!Physics.CheckCapsule(val, val2, 0.45f, SolidMask, (QueryTriggerInteraction)1))
		{
			return false;
		}
		Vector3[] array = (Vector3[])(object)new Vector3[5]
		{
			Vector3.zero,
			new Vector3(0.45f, 0f, 0f),
			new Vector3(-0.45f, 0f, 0f),
			new Vector3(0f, 0f, 0.45f),
			new Vector3(0f, 0f, -0.45f)
		};
		int num = 0;
		for (int i = 0; i < array.Length; i++)
		{
			Vector3 val3 = val + array[i];
			Vector3 val4 = val2 + array[i];
			if (Physics.CheckCapsule(val3, val4, 0.45f, SolidMask, (QueryTriggerInteraction)1))
			{
				num++;
			}
		}
		return num >= 3;
	}

	private static bool IsMistlandsSpawnSpaceBlocked_Local(Vector3 groundPoint)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0080: Unknown result type (might be due to invalid IL or missing references)
		//IL_0085: Unknown result type (might be due to invalid IL or missing references)
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00da: Unknown result type (might be due to invalid IL or missing references)
		//IL_00df: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
		Vector3 val = groundPoint + Vector3.up * 0.2f;
		Vector3 val2 = val + Vector3.up * 1.85f;
		if (!Physics.CheckCapsule(val, val2, 0.3f, SolidMask, (QueryTriggerInteraction)1))
		{
			return false;
		}
		Vector3[] array = (Vector3[])(object)new Vector3[5]
		{
			Vector3.zero,
			new Vector3(0.3f, 0f, 0f),
			new Vector3(-0.3f, 0f, 0f),
			new Vector3(0f, 0f, 0.3f),
			new Vector3(0f, 0f, -0.3f)
		};
		int num = 0;
		for (int i = 0; i < array.Length; i++)
		{
			Vector3 val3 = val + array[i];
			Vector3 val4 = val2 + array[i];
			if (Physics.CheckCapsule(val3, val4, 0.3f, SolidMask, (QueryTriggerInteraction)1))
			{
				num++;
			}
		}
		return num >= 5;
	}

	private static bool HasAnyKnownRikoInWorld()
	{
		if (LoadedRikos.Count > 0)
		{
			return true;
		}
		foreach (KeyValuePair<string, int> worldCount in WorldCounts)
		{
			if (worldCount.Value > 0)
			{
				return true;
			}
		}
		return false;
	}

	private static void EnsureWorldCounts_Cached(bool initial)
	{
		float time = Time.time;
		if (!WorldCountCacheInitialized)
		{
			RescanWorldCounts_GlobalZdo("init");
			WorldCountCacheInitialized = true;
			NextWorldCountRescanTime = time + 90f;
		}
		else if (!initial && !(time < NextWorldCountRescanTime))
		{
			RescanWorldCounts_GlobalZdo("timer");
			NextWorldCountRescanTime = time + 90f;
		}
	}

	private static void RescanWorldCounts_GlobalZdo(string reason)
	{
		WorldCounts.Clear();
		if (ZDOMan.instance == null)
		{
			return;
		}
		int num = 0;
		int num2 = 0;
		for (int i = 0; i < Defs.Length; i++)
		{
			LivingContainerDef livingContainerDef = Defs[i];
			if (livingContainerDef == null || string.IsNullOrEmpty(livingContainerDef.Prefab))
			{
				continue;
			}
			int num3 = 0;
			PurgeZdos.Clear();
			bool flag = false;
			int num4 = 0;
			try
			{
				while (!flag && num4 < 10000)
				{
					flag = ZDOMan.instance.GetAllZDOsWithPrefabIterative(livingContainerDef.Prefab, PurgeZdos, ref num3);
					num4++;
				}
			}
			catch
			{
				EnsureWorldCounts_LoadedFallback();
				PurgeZdos.Clear();
				LogPerf("WorldCounts RESCAN_FALLBACK reason=" + reason + " note=iterativeFailed");
				return;
			}
			int num5 = 0;
			for (int j = 0; j < PurgeZdos.Count; j++)
			{
				ZDO val = PurgeZdos[j];
				if (val != null)
				{
					int num6 = 0;
					try
					{
						num6 = val.GetInt("MS_Riko_Killed", 0);
					}
					catch
					{
					}
					if (num6 != 1)
					{
						num5++;
					}
				}
			}
			WorldCounts[livingContainerDef.Prefab] = num5;
			num++;
			num2 += PurgeZdos.Count;
		}
		PurgeZdos.Clear();
		LogPerf($"WorldCounts RESCAN_OK reason={reason} prefabs={num} scannedZdos={num2}");
	}

	private static void EnsureWorldCounts_LoadedFallback()
	{
		WorldCounts.Clear();
		foreach (KeyValuePair<ZDOID, ZNetView> loadedRiko in LoadedRikos)
		{
			ZNetView value = loadedRiko.Value;
			if ((Object)(object)value == (Object)null || !value.IsValid())
			{
				continue;
			}
			string prefabName = Utils.GetPrefabName(((Object)((Component)value).gameObject).name);
			if (!DefByPrefab.ContainsKey(prefabName))
			{
				continue;
			}
			ZDO val = null;
			try
			{
				val = value.GetZDO();
			}
			catch
			{
			}
			if (val != null)
			{
				int num = 0;
				try
				{
					num = val.GetInt("MS_Riko_Killed", 0);
				}
				catch
				{
				}
				if (num == 1)
				{
					continue;
				}
			}
			WorldCounts[prefabName] = ((!WorldCounts.TryGetValue(prefabName, out var value2)) ? 1 : (value2 + 1));
		}
	}

	private static int GetAuthoritativeAliveCountForPrefab(string prefabName)
	{
		if (string.IsNullOrEmpty(prefabName))
		{
			return 0;
		}
		int value;
		int num = (WorldCounts.TryGetValue(prefabName, out value) ? value : 0);
		if (ZDOMan.instance == null)
		{
			return num;
		}
		float time = Time.time;
		if (NextAuthoritativeCountCheckTime.TryGetValue(prefabName, out var value2) && time < value2)
		{
			return num;
		}
		int num2 = 0;
		PurgeZdos.Clear();
		bool flag = false;
		int num3 = 0;
		try
		{
			while (!flag && num3 < 10000)
			{
				flag = ZDOMan.instance.GetAllZDOsWithPrefabIterative(prefabName, PurgeZdos, ref num2);
				num3++;
			}
		}
		catch
		{
			NextAuthoritativeCountCheckTime[prefabName] = time + 20f;
			int num4 = num;
			LogPerf($"WorldCounts AUTHORITATIVE_FALLBACK prefab={prefabName} cached={num4} note=iterativeFailed");
			PurgeZdos.Clear();
			return num4;
		}
		int num5 = 0;
		for (int i = 0; i < PurgeZdos.Count; i++)
		{
			ZDO val = PurgeZdos[i];
			if (val != null)
			{
				int num6 = 0;
				try
				{
					num6 = val.GetInt("MS_Riko_Killed", 0);
				}
				catch
				{
				}
				if (num6 != 1)
				{
					num5++;
				}
			}
		}
		PurgeZdos.Clear();
		WorldCounts[prefabName] = num5;
		NextAuthoritativeCountCheckTime[prefabName] = time + 20f;
		LogPerf($"WorldCounts AUTHORITATIVE prefab={prefabName} count={num5}");
		return num5;
	}

	private static void SweepRegistryInvalidEntriesIfNeeded()
	{
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
		LoadedRegistryInvalidSweeps++;
		if (LoadedRegistryInvalidSweeps < 10)
		{
			return;
		}
		LoadedRegistryInvalidSweeps = 0;
		if (LoadedRikos.Count == 0)
		{
			return;
		}
		if (_registrySweepKeys == null)
		{
			_registrySweepKeys = new List<ZDOID>(128);
		}
		_registrySweepKeys.Clear();
		foreach (KeyValuePair<ZDOID, ZNetView> loadedRiko in LoadedRikos)
		{
			ZNetView value = loadedRiko.Value;
			if ((Object)(object)value == (Object)null || !value.IsValid())
			{
				_registrySweepKeys.Add(loadedRiko.Key);
			}
		}
		for (int i = 0; i < _registrySweepKeys.Count; i++)
		{
			LoadedRikos.Remove(_registrySweepKeys[i]);
		}
		if (_registrySweepKeys.Count > 0)
		{
			LogPerf($"registry SWEEP removed={_registrySweepKeys.Count} remaining={LoadedRikos.Count}");
		}
	}

	private static void UpdateLastSeenForLoadedRikos()
	{
		//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
		float time = Time.time;
		if (time < NextSeenUpdateTime)
		{
			return;
		}
		NextSeenUpdateTime = time + 12f;
		if (LoadedRikos.Count == 0 || OriginPositions.Count == 0)
		{
			return;
		}
		float num = 14400f;
		long nowSeconds = GetNowSeconds();
		SweepRegistryInvalidEntriesIfNeeded();
		foreach (KeyValuePair<ZDOID, ZNetView> loadedRiko in LoadedRikos)
		{
			ZNetView value = loadedRiko.Value;
			if ((Object)(object)value == (Object)null || !value.IsValid())
			{
				continue;
			}
			string prefabName = Utils.GetPrefabName(((Object)((Component)value).gameObject).name);
			if (!DefByPrefab.ContainsKey(prefabName))
			{
				continue;
			}
			ZDO val = null;
			try
			{
				val = value.GetZDO();
			}
			catch
			{
			}
			if (val != null)
			{
				int num2 = 0;
				try
				{
					num2 = val.GetInt("MS_Riko_Killed", 0);
				}
				catch
				{
				}
				if (num2 == 1)
				{
					continue;
				}
			}
			Vector3 position = ((Component)value).transform.position;
			bool flag = false;
			for (int i = 0; i < OriginPositions.Count; i++)
			{
				Vector3 val2 = OriginPositions[i] - position;
				if (((Vector3)(ref val2)).sqrMagnitude <= num)
				{
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				continue;
			}
			try
			{
				if (val != null)
				{
					val.Set("MS_Riko_LastSeenTime", nowSeconds);
				}
			}
			catch
			{
			}
		}
		LogPerf($"SeenUpdate tick interval={12f:0.0} loaded={LoadedRikos.Count} origins={OriginPositions.Count}");
	}

	private static void TryDestroyKilledRikoFromZdo(ZDO zdo, string prefabName, long nowS, string reason)
	{
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		if (zdo == null || string.IsNullOrEmpty(prefabName))
		{
			return;
		}
		long num = 0L;
		try
		{
			num = zdo.GetLong("MS_Riko_DestroyAt", 0L);
		}
		catch
		{
		}
		if (num <= 0)
		{
			num = nowS;
		}
		if (nowS < num)
		{
			return;
		}
		GameObject val = null;
		try
		{
			if ((Object)(object)ZNetScene.instance != (Object)null)
			{
				val = ZNetScene.instance.FindInstance(zdo.m_uid);
			}
		}
		catch
		{
			val = null;
		}
		if ((Object)(object)val != (Object)null)
		{
			ZNetView val2 = null;
			try
			{
				val2 = val.GetComponent<ZNetView>();
			}
			catch
			{
			}
			if ((Object)(object)val2 != (Object)null && val2.IsValid())
			{
				DestroyKilledLoadedRiko(val2, prefabName, reason, playFx: false);
				return;
			}
		}
		ForceDestroyZDO_AndEnqueue(zdo, prefabName, reason + " notLoaded");
	}

	private static void ProcessLoadedDestroyDueFast()
	{
		float time = Time.time;
		if (time < NextLoadedDestroyCheckTime)
		{
			return;
		}
		NextLoadedDestroyCheckTime = time + 0.2f;
		if (LoadedRikos.Count == 0)
		{
			return;
		}
		long nowSeconds = GetNowSeconds();
		SweepRegistryInvalidEntriesIfNeeded();
		foreach (KeyValuePair<ZDOID, ZNetView> loadedRiko in LoadedRikos)
		{
			ZNetView value = loadedRiko.Value;
			if ((Object)(object)value == (Object)null || !value.IsValid())
			{
				continue;
			}
			ZDO val = null;
			try
			{
				val = value.GetZDO();
			}
			catch
			{
			}
			if (val == null)
			{
				continue;
			}
			int num = 0;
			long num2 = 0L;
			try
			{
				num = val.GetInt("MS_Riko_Killed", 0);
			}
			catch
			{
			}
			if (num != 1)
			{
				continue;
			}
			try
			{
				num2 = val.GetLong("MS_Riko_DestroyAt", 0L);
			}
			catch
			{
			}
			if (num2 <= 0)
			{
				num2 = nowSeconds;
			}
			if (nowSeconds >= num2)
			{
				string prefabName = Utils.GetPrefabName(((Object)((Component)value).gameObject).name);
				if (DefByPrefab.ContainsKey(prefabName))
				{
					DestroyKilledLoadedRiko(value, prefabName, "LoadedFastDue", playFx: false);
				}
			}
		}
	}

	private static void ProcessScheduledDestroyForLoadedRikos()
	{
		float time = Time.time;
		if (time < NextDestroyScanTime)
		{
			return;
		}
		NextDestroyScanTime = time + 20f;
		if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || ZDOMan.instance == null || LoadedRikos.Count == 0)
		{
			return;
		}
		long nowSeconds = GetNowSeconds();
		int num = 0;
		int num2 = 0;
		int num3 = 0;
		for (int i = 0; i < Defs.Length; i++)
		{
			LivingContainerDef livingContainerDef = Defs[i];
			if (livingContainerDef == null || string.IsNullOrEmpty(livingContainerDef.Prefab))
			{
				continue;
			}
			int num4 = 0;
			PurgeZdos.Clear();
			bool flag = false;
			int num5 = 0;
			try
			{
				while (!flag && num5 < 10000)
				{
					flag = ZDOMan.instance.GetAllZDOsWithPrefabIterative(livingContainerDef.Prefab, PurgeZdos, ref num4);
					num5++;
				}
			}
			catch
			{
				PurgeZdos.Clear();
				continue;
			}
			num++;
			num2 += PurgeZdos.Count;
			for (int j = 0; j < PurgeZdos.Count; j++)
			{
				ZDO val = PurgeZdos[j];
				if (val == null)
				{
					continue;
				}
				int num6 = 0;
				try
				{
					num6 = val.GetInt("MS_Riko_Killed", 0);
				}
				catch
				{
				}
				if (num6 == 1)
				{
					long num7 = 0L;
					try
					{
						num7 = val.GetLong("MS_Riko_DestroyAt", 0L);
					}
					catch
					{
					}
					if (num7 <= 0)
					{
						num7 = nowSeconds;
					}
					if (nowSeconds >= num7)
					{
						num3++;
						TryDestroyKilledRikoFromZdo(val, livingContainerDef.Prefab, nowSeconds, "ScheduledDestroy due");
					}
				}
			}
			PurgeZdos.Clear();
		}
		LogPerf($"DestroyScan tick interval={20f:0.0} " + $"prefabs={num} scannedZdos={num2} dueKilled={num3}");
	}

	private static void TryRunEmptyWatcher_Server()
	{
		//IL_0213: Unknown result type (might be due to invalid IL or missing references)
		if (!LivingContainerConfig.IsRikoEnabled() || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || ZDOMan.instance == null || (!_emptyWatcherInProgress && !HasAnyKnownRikoInWorld()))
		{
			return;
		}
		float time = Time.time;
		if (!_emptyWatcherInProgress && time < _emptyWatcherNextRunTime)
		{
			return;
		}
		CleanupItemsCacheIfNeeded();
		EnsureZdoVarHashes();
		BuildDefCache();
		if (!_emptyWatcherInProgress)
		{
			_emptyWatcherInProgress = true;
			_emptyWatcherPrefabIndex = 0;
			_emptyWatcherSectorIndex = 0;
			_emptyWatcherZdos.Clear();
			_emptyWatcherNextRunTime = time + 30f;
		}
		string text = null;
		while (_emptyWatcherPrefabIndex < Defs.Length)
		{
			LivingContainerDef livingContainerDef = Defs[_emptyWatcherPrefabIndex];
			if (livingContainerDef != null && !string.IsNullOrEmpty(livingContainerDef.Prefab))
			{
				text = livingContainerDef.Prefab;
				break;
			}
			_emptyWatcherPrefabIndex++;
		}
		if (text == null)
		{
			_emptyWatcherInProgress = false;
			return;
		}
		bool allZDOsWithPrefabIterative;
		try
		{
			allZDOsWithPrefabIterative = ZDOMan.instance.GetAllZDOsWithPrefabIterative(text, _emptyWatcherZdos, ref _emptyWatcherSectorIndex);
		}
		catch
		{
			_emptyWatcherInProgress = false;
			_emptyWatcherZdos.Clear();
			return;
		}
		if (!allZDOsWithPrefabIterative)
		{
			return;
		}
		int num = 0;
		int num2 = 0;
		int num3 = 0;
		int num4 = 0;
		int num5 = 0;
		int num6 = 0;
		int num7 = 0;
		long nowSeconds = GetNowSeconds();
		LivingContainerDef value;
		bool flag = DefByPrefab.TryGetValue(text, out value);
		for (int i = 0; i < _emptyWatcherZdos.Count; i++)
		{
			ZDO val = _emptyWatcherZdos[i];
			if (val == null)
			{
				continue;
			}
			num++;
			int num8 = 0;
			long num9 = 0L;
			try
			{
				num8 = val.GetInt("MS_Riko_Killed", 0);
			}
			catch
			{
			}
			try
			{
				num9 = val.GetLong("MS_Riko_DestroyAt", 0L);
			}
			catch
			{
			}
			if (num8 == 1)
			{
				num2++;
				continue;
			}
			if (num9 > 0)
			{
				num2++;
				continue;
			}
			int num10 = 0;
			try
			{
				if (_hashInUse != 0)
				{
					num10 = val.GetInt(_hashInUse, 0);
				}
			}
			catch
			{
				num10 = 0;
			}
			if (num10 != 0)
			{
				num3++;
				continue;
			}
			if (!ZdoInventoryIsEmptyDecoded_Cached(text, val, out var _, out var _, out var _))
			{
				num4++;
				continue;
			}
			GameObject val2 = null;
			try
			{
				val2 = (((Object)(object)ZNetScene.instance != (Object)null) ? ZNetScene.instance.FindInstance(val.m_uid) : null);
			}
			catch
			{
			}
			if ((Object)(object)val2 != (Object)null)
			{
				long num11 = 0L;
				if (flag && value != null && value.DestroyDelay > 0f)
				{
					num11 = Mathf.CeilToInt(value.DestroyDelay);
				}
				long destroyAtS = nowSeconds + num11;
				bool num12 = TryMarkKilledIfNeeded(val, text, destroyAtS, "EmptyWatcher");
				if (num12)
				{
					num5++;
				}
				if (!num12)
				{
					continue;
				}
				ZNetView val3 = null;
				try
				{
					val3 = val2.GetComponent<ZNetView>();
				}
				catch
				{
				}
				if ((Object)(object)val3 != (Object)null && val3.IsValid())
				{
					TriggerLoadedRikoVanishWithFx(val3, text, "EmptyWatcher loaded");
					num6++;
					if (num11 <= 0)
					{
						DestroyKilledLoadedRiko(val3, text, "EmptyWatcher loaded delay=0", playFx: false);
					}
				}
			}
			else
			{
				ForceDestroyZDO_AndEnqueue(val, text, "EmptyWatcher notLoaded immediate");
				num7++;
			}
		}
		LogWatcher($"server EmptyWatcher SUMMARY prefab={text} scanned={num} skippedKilled={num2} skippedInUse={num3} skippedNotEmpty={num4} " + $"markedKilled={num5} immediateLoaded={num6} immediateZdo={num7} cacheSize={_itemsCache.Count}");
		_emptyWatcherPrefabIndex++;
		_emptyWatcherSectorIndex = 0;
		_emptyWatcherZdos.Clear();
		if (_emptyWatcherPrefabIndex >= Defs.Length)
		{
			_emptyWatcherInProgress = false;
		}
	}

	private static void EnsureZdoVarHashes()
	{
		if (_hashInUse != 0 && _hashItems != 0)
		{
			return;
		}
		try
		{
			FieldInfo fieldInfo = AccessTools.Field(typeof(ZDOVars), "s_inUse");
			if (fieldInfo != null)
			{
				object value = fieldInfo.GetValue(null);
				if (value is int)
				{
					int num = (int)value;
					if (num != 0)
					{
						_hashInUse = num;
					}
				}
			}
		}
		catch
		{
		}
		try
		{
			FieldInfo fieldInfo2 = AccessTools.Field(typeof(ZDOVars), "s_items");
			if (fieldInfo2 != null)
			{
				object value2 = fieldInfo2.GetValue(null);
				if (value2 is int)
				{
					int num2 = (int)value2;
					if (num2 != 0)
					{
						_hashItems = num2;
					}
				}
			}
		}
		catch
		{
		}
		if (_hashInUse == 0)
		{
			try
			{
				_hashInUse = StringExtensionMethods.GetStableHashCode("InUse");
			}
			catch
			{
			}
		}
		if (_hashItems == 0)
		{
			try
			{
				_hashItems = StringExtensionMethods.GetStableHashCode("items");
			}
			catch
			{
			}
		}
	}

	private static int ComputeQuickHash(string s)
	{
		if (string.IsNullOrEmpty(s))
		{
			return 0;
		}
		int num = 17;
		int length = s.Length;
		num = num * 31 + length;
		int num2 = Mathf.Min(16, length);
		for (int i = 0; i < num2; i++)
		{
			num = num * 31 + s[i];
		}
		int num3 = Mathf.Min(16, length - num2);
		for (int j = 0; j < num3; j++)
		{
			num = num * 31 + s[length - 1 - j];
		}
		return num;
	}

	private static bool ZdoInventoryIsEmptyDecoded_Cached(string rootPrefabName, ZDO zdo, out int decodedCount, out int itemsLen, out string itemsPreview)
	{
		//IL_026c: Unknown result type (might be due to invalid IL or missing references)
		//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d2: Expected O, but got Unknown
		//IL_0218: Unknown result type (might be due to invalid IL or missing references)
		//IL_0131: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01db: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ea: Expected O, but got Unknown
		//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
		decodedCount = -1;
		itemsLen = -1;
		itemsPreview = "";
		if (zdo == null)
		{
			return false;
		}
		EnsureZdoVarHashes();
		string text = "";
		byte[] array = null;
		try
		{
			if (_hashItems != 0)
			{
				text = zdo.GetString(_hashItems, "");
			}
		}
		catch
		{
			text = "";
		}
		if (text == null)
		{
			text = "";
		}
		itemsLen = text.Length;
		if (string.IsNullOrEmpty(text))
		{
			decodedCount = 0;
			_itemsCache[zdo.m_uid] = new ItemsCacheEntry
			{
				ItemsLen = 0,
				QuickHash = 0,
				IsEmpty = true,
				DecodedCount = 0,
				LastTouchTime = Time.time
			};
			return true;
		}
		int num = ComputeQuickHash(text);
		if (_itemsCache.TryGetValue(zdo.m_uid, out var value) && value.ItemsLen == itemsLen && value.QuickHash == num)
		{
			value.LastTouchTime = Time.time;
			_itemsCache[zdo.m_uid] = value;
			decodedCount = value.DecodedCount;
			return value.IsEmpty;
		}
		if (itemsLen <= 0)
		{
			try
			{
				if (_hashItems != 0)
				{
					array = zdo.GetByteArray(_hashItems, (byte[])null);
				}
			}
			catch
			{
				array = null;
			}
			if (array == null || array.Length == 0)
			{
				decodedCount = 0;
				_itemsCache[zdo.m_uid] = new ItemsCacheEntry
				{
					ItemsLen = 0,
					QuickHash = 0,
					IsEmpty = true,
					DecodedCount = 0,
					LastTouchTime = Time.time
				};
				return true;
			}
		}
		try
		{
			int num2 = 4;
			int num3 = 1;
			if (LivingContainerConfig.RikoConfigs.TryGetValue(GetRikoId(rootPrefabName), out var value2))
			{
				try
				{
					num2 = Mathf.Max(1, value2.ContainerWidth.Value);
				}
				catch
				{
				}
				try
				{
					num3 = Mathf.Max(1, value2.ContainerHeight.Value);
				}
				catch
				{
				}
			}
			Inventory val = new Inventory("MS_Riko_tmp", (Sprite)null, num2, num3);
			ZPackage val2 = ((!string.IsNullOrEmpty(text)) ? new ZPackage(text) : new ZPackage(array));
			val.Load(val2);
			int num4 = 0;
			try
			{
				num4 = val.NrOfItems();
			}
			catch
			{
				num4 = 0;
			}
			decodedCount = num4;
			bool flag = num4 == 0;
			_itemsCache[zdo.m_uid] = new ItemsCacheEntry
			{
				ItemsLen = itemsLen,
				QuickHash = num,
				IsEmpty = flag,
				DecodedCount = num4,
				LastTouchTime = Time.time
			};
			return flag;
		}
		catch
		{
			decodedCount = -2;
			_itemsCache[zdo.m_uid] = new ItemsCacheEntry
			{
				ItemsLen = itemsLen,
				QuickHash = num,
				IsEmpty = false,
				DecodedCount = -2,
				LastTouchTime = Time.time
			};
			return false;
		}
	}

	private static void CleanupItemsCacheIfNeeded()
	{
		//IL_0093: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_013d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0181: Unknown result type (might be due to invalid IL or missing references)
		float time = Time.time;
		if (time < _itemsCacheNextCleanupTime)
		{
			return;
		}
		_itemsCacheNextCleanupTime = time + 60f;
		if (_itemsCache.Count == 0)
		{
			return;
		}
		float num = ((_itemsCache.Count > 4096) ? 210f : 600f);
		if (_itemsCacheKeysTmp == null)
		{
			_itemsCacheKeysTmp = new List<ZDOID>(256);
		}
		_itemsCacheKeysTmp.Clear();
		foreach (KeyValuePair<ZDOID, ItemsCacheEntry> item in _itemsCache)
		{
			if (time - item.Value.LastTouchTime > num)
			{
				_itemsCacheKeysTmp.Add(item.Key);
			}
		}
		for (int i = 0; i < _itemsCacheKeysTmp.Count; i++)
		{
			_itemsCache.Remove(_itemsCacheKeysTmp[i]);
		}
		if (_itemsCache.Count <= 4096)
		{
			return;
		}
		_itemsCacheKeysTmp.Clear();
		int num2 = Mathf.Min(_itemsCache.Count - 4096, 512);
		foreach (KeyValuePair<ZDOID, ItemsCacheEntry> item2 in _itemsCache)
		{
			_itemsCacheKeysTmp.Add(item2.Key);
			if (_itemsCacheKeysTmp.Count >= num2)
			{
				break;
			}
		}
		for (int j = 0; j < _itemsCacheKeysTmp.Count; j++)
		{
			_itemsCache.Remove(_itemsCacheKeysTmp[j]);
		}
	}

	private static bool EnsureServerOwnership(ZNetView nv, ZDO zdo, string reason)
	{
		if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
		{
			return false;
		}
		bool flag = false;
		try
		{
			if ((Object)(object)nv != (Object)null && nv.IsValid())
			{
				if (nv.IsOwner())
				{
					return true;
				}
				try
				{
					nv.ClaimOwnership();
				}
				catch
				{
				}
				if (nv.IsOwner())
				{
					flag = true;
				}
			}
		}
		catch
		{
		}
		try
		{
			if (!flag && zdo != null)
			{
				if (!zdo.IsOwner())
				{
					zdo.SetOwner(ZDOMan.GetSessionID());
				}
				if (zdo.IsOwner())
				{
					flag = true;
				}
			}
		}
		catch
		{
		}
		if (!flag)
		{
			bool flag2 = false;
			bool flag3 = false;
			try
			{
				flag2 = (Object)(object)nv != (Object)null && nv.IsValid() && nv.IsOwner();
			}
			catch
			{
			}
			try
			{
				flag3 = zdo != null && zdo.IsOwner();
			}
			catch
			{
			}
			LogLife(string.Format("server Ownership FAIL reason={0} uid={1} nvOwner={2} zdoOwner={3}", reason, (zdo != null) ? ((object)(ZDOID)(ref zdo.m_uid)).ToString() : "null", flag2, flag3));
		}
		return flag;
	}

	private static bool TryMarkKilledIfNeeded(ZDO zdo, string prefab, long destroyAtS, string reason, ZNetView nvMaybe = null)
	{
		//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_0066: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
		if (zdo == null || string.IsNullOrEmpty(prefab))
		{
			return false;
		}
		int num = 0;
		long num2 = 0L;
		try
		{
			num = zdo.GetInt("MS_Riko_Killed", 0);
		}
		catch
		{
		}
		try
		{
			num2 = zdo.GetLong("MS_Riko_DestroyAt", 0L);
		}
		catch
		{
		}
		if (num == 1)
		{
			return false;
		}
		if (num2 > 0)
		{
			return false;
		}
		if (!EnsureServerOwnership(nvMaybe, zdo, "MarkKilled(" + reason + ")"))
		{
			LogLife($"server MarkKilled SKIP_NOT_OWNER prefab={prefab} uid={zdo.m_uid} reason={reason}");
			return false;
		}
		try
		{
			zdo.Set("MS_Riko_Killed", 1);
			zdo.Set("MS_Riko_DestroyAt", destroyAtS);
		}
		catch
		{
			LogLife($"server MarkKilled SET_FAIL prefab={prefab} uid={zdo.m_uid} reason={reason}");
			return false;
		}
		_itemsCache.Remove(zdo.m_uid);
		LogLife($"server MarkKilled OK prefab={prefab} uid={zdo.m_uid} destroyAt={destroyAtS} reason={reason}");
		return true;
	}

	private static bool TryPlayVfxOnce(ZDO zdo, LivingContainerDef def, GameObject go, string prefabName, string reason)
	{
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		if (zdo == null || def == null || (Object)(object)go == (Object)null)
		{
			return false;
		}
		try
		{
			if (zdo.GetInt("MS_Riko_VfxPlayed", 0) == 1)
			{
				return false;
			}
			zdo.Set("MS_Riko_VfxPlayed", 1);
		}
		catch
		{
		}
		bool flag = SpawnVfx(def, go);
		LogLife($"server VFX PLAY prefab={prefabName} uid={zdo.m_uid} spawned={flag} reason={reason}");
		return flag;
	}

	private static bool TryDecrementWorldCountOnFinalDestroy(ZDO zdo, string prefab, string reason)
	{
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		if (zdo == null || string.IsNullOrEmpty(prefab))
		{
			return false;
		}
		try
		{
			if (zdo.GetInt("MS_Riko_FinalDestroyCounted", 0) == 1)
			{
				return false;
			}
			zdo.Set("MS_Riko_FinalDestroyCounted", 1);
		}
		catch
		{
		}
		if (!WorldCounts.TryGetValue(prefab, out var value))
		{
			return false;
		}
		int num = Mathf.Max(0, value - 1);
		WorldCounts[prefab] = num;
		LogPerf($"WorldCounts FINAL_DEC prefab={prefab} {value}->{num} reason={reason} uid={zdo.m_uid}");
		return true;
	}

	private static void TriggerLoadedRikoVanishWithFx(ZNetView nv, string prefabName, string reason)
	{
		if (!((Object)(object)nv == (Object)null) && nv.IsValid())
		{
			ZDO val = null;
			try
			{
				val = nv.GetZDO();
			}
			catch
			{
			}
			if (EnsureServerOwnership(nv, val, "TriggerLoadedVanish(" + reason + ")") && DefByPrefab.TryGetValue(prefabName, out var value) && value != null)
			{
				bool flag = TryPlayVfxOnce(val, value, ((Component)nv).gameObject, prefabName, reason);
				LogLife(string.Format("server TriggerLoadedVanish prefab={0} uid={1} ok={2} reason={3}", prefabName, (val != null) ? ((object)(ZDOID)(ref val.m_uid)).ToString() : "null", flag, reason));
			}
		}
	}

	private static void DestroyKilledLoadedRiko(ZNetView nv, string prefabName, string reason, bool playFx)
	{
		if ((Object)(object)nv == (Object)null || !nv.IsValid())
		{
			return;
		}
		ZDO val = null;
		try
		{
			val = nv.GetZDO();
		}
		catch
		{
		}
		if (!EnsureServerOwnership(nv, val, "DestroyLoaded(" + reason + ")"))
		{
			return;
		}
		LivingContainerDef value = null;
		DefByPrefab.TryGetValue(prefabName, out value);
		if (playFx && value != null)
		{
			TryPlayVfxOnce(val, value, ((Component)nv).gameObject, prefabName, reason);
		}
		try
		{
			TryDecrementWorldCountOnFinalDestroy(val, prefabName, "LoadedDestroy(" + reason + ")");
			nv.Destroy();
			LogLife(string.Format("server LoadedDestroy OK prefab={0} uid={1} playFx={2} reason={3}", prefabName, (val != null) ? ((object)(ZDOID)(ref val.m_uid)).ToString() : "null", playFx, reason));
		}
		catch
		{
			try
			{
				if (val != null)
				{
					ForceDestroyZDO_AndEnqueue(val, prefabName, "LoadedDestroyFallback(" + reason + ")");
				}
			}
			catch
			{
			}
		}
	}

	private static void ForceDestroyZDO_AndEnqueue(ZDO zdo, string prefabName, string reason)
	{
		//IL_0093: Unknown result type (might be due to invalid IL or missing references)
		//IL_0074: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		if (zdo == null || ZDOMan.instance == null)
		{
			return;
		}
		try
		{
			if (!zdo.IsOwner())
			{
				zdo.SetOwner(ZDOMan.GetSessionID());
			}
		}
		catch
		{
		}
		try
		{
			if (zdo.IsOwner())
			{
				TryDecrementWorldCountOnFinalDestroy(zdo, prefabName, "DestroyZDO(" + reason + ")");
				ZDOMan.instance.DestroyZDO(zdo);
				LogLife($"server Enqueued DestroyZDO reason={reason} uid={zdo.m_uid}");
			}
			else
			{
				LogLife($"server DestroyZDO NOT_OWNER reason={reason} uid={zdo.m_uid}");
			}
		}
		catch
		{
		}
		_itemsCache.Remove(zdo.m_uid);
	}

	private static void TryPurgeExpiredOrKilledRikoZDOs()
	{
		//IL_0164: Unknown result type (might be due to invalid IL or missing references)
		//IL_0221: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || ZDOMan.instance == null || (!PurgeInProgress && !HasAnyKnownRikoInWorld()))
		{
			return;
		}
		float time = Time.time;
		if (!PurgeInProgress)
		{
			if (time < NextTtlScanTime)
			{
				return;
			}
			NextTtlScanTime = time + 45f;
			PurgeInProgress = true;
			PurgePrefabIndex = 0;
			PurgeSectorIndex = 0;
			PurgeZdos.Clear();
		}
		string text = null;
		while (PurgePrefabIndex < Defs.Length)
		{
			LivingContainerDef livingContainerDef = Defs[PurgePrefabIndex];
			if (livingContainerDef != null && !string.IsNullOrEmpty(livingContainerDef.Prefab))
			{
				text = livingContainerDef.Prefab;
				break;
			}
			PurgePrefabIndex++;
		}
		if (text == null)
		{
			PurgeInProgress = false;
			return;
		}
		bool allZDOsWithPrefabIterative;
		try
		{
			allZDOsWithPrefabIterative = ZDOMan.instance.GetAllZDOsWithPrefabIterative(text, PurgeZdos, ref PurgeSectorIndex);
		}
		catch
		{
			PurgeInProgress = false;
			return;
		}
		if (!allZDOsWithPrefabIterative)
		{
			return;
		}
		long nowSeconds = GetNowSeconds();
		long num = 1200L;
		long num2 = 120L;
		for (int i = 0; i < PurgeZdos.Count; i++)
		{
			ZDO val = PurgeZdos[i];
			if (val == null)
			{
				continue;
			}
			int num3 = 0;
			long num4 = 0L;
			try
			{
				num3 = val.GetInt("MS_Riko_Killed", 0);
			}
			catch
			{
			}
			if (num3 == 1)
			{
				try
				{
					num4 = val.GetLong("MS_Riko_DestroyAt", 0L);
				}
				catch
				{
				}
				if (num4 > 0 && nowSeconds < num4)
				{
					continue;
				}
				try
				{
					if ((Object)(object)ZNetScene.instance.FindInstance(val.m_uid) != (Object)null)
					{
						continue;
					}
				}
				catch
				{
				}
				ForceDestroyZDO_AndEnqueue(val, text, "TTL killed=1 due");
				continue;
			}
			long num5 = 0L;
			long num6 = 0L;
			try
			{
				num5 = val.GetLong("MS_Riko_SpawnTime", 0L);
				num6 = val.GetLong("MS_Riko_LastSeenTime", 0L);
			}
			catch
			{
				continue;
			}
			if (num5 <= 0)
			{
				try
				{
					val.Set("MS_Riko_SpawnTime", nowSeconds);
				}
				catch
				{
				}
				try
				{
					val.Set("MS_Riko_LastSeenTime", nowSeconds);
				}
				catch
				{
				}
				continue;
			}
			if (num6 <= 0)
			{
				try
				{
					val.Set("MS_Riko_LastSeenTime", nowSeconds);
				}
				catch
				{
				}
				continue;
			}
			long num7 = nowSeconds - num5;
			long num8 = nowSeconds - num6;
			if (num7 < num || num8 < num2)
			{
				continue;
			}
			try
			{
				if ((Object)(object)ZNetScene.instance.FindInstance(val.m_uid) != (Object)null)
				{
					continue;
				}
			}
			catch
			{
			}
			TryMarkKilledIfNeeded(val, text, nowSeconds, "TTL expired");
			ForceDestroyZDO_AndEnqueue(val, text, "TTL expired");
		}
		PurgePrefabIndex++;
		PurgeSectorIndex = 0;
		PurgeZdos.Clear();
		if (PurgePrefabIndex >= Defs.Length)
		{
			PurgeInProgress = false;
		}
	}

	[HarmonyPostfix]
	[HarmonyPatch(typeof(ZNetView), "Awake")]
	private static void ZNetView_Awake_Postfix(ZNetView __instance)
	{
		//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
		if (!LivingContainerConfig.IsRikoEnabled() || (Object)(object)__instance == (Object)null)
		{
			return;
		}
		GameObject gameObject = ((Component)__instance).gameObject;
		if ((Object)(object)gameObject == (Object)null)
		{
			return;
		}
		BuildDefCache();
		string prefabName = Utils.GetPrefabName(((Object)gameObject).name);
		if (!DefByPrefab.TryGetValue(prefabName, out var value))
		{
			return;
		}
		AttachPinComponent(gameObject, value);
		EnsureRegistryComponent(gameObject);
		ZDO val = null;
		try
		{
			val = __instance.GetZDO();
		}
		catch
		{
		}
		if (val == null)
		{
			return;
		}
		int num = 0;
		long num2 = 0L;
		try
		{
			num = val.GetInt("MS_Riko_Killed", 0);
		}
		catch
		{
		}
		try
		{
			num2 = val.GetLong("MS_Riko_DestroyAt", 0L);
		}
		catch
		{
		}
		if (num == 1 && (Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
		{
			long nowSeconds = GetNowSeconds();
			if (num2 <= 0 || nowSeconds >= num2)
			{
				DestroyKilledLoadedRiko(__instance, prefabName, "ZNetView.Awake killed due", playFx: true);
				return;
			}
			LogLife($"server KilledObject KEEP_UNTIL prefab={prefabName} uid={val.m_uid} now={nowSeconds} destroyAt={num2}");
		}
		try
		{
			long nowSeconds2 = GetNowSeconds();
			if (val.GetLong("MS_Riko_SpawnTime", 0L) <= 0)
			{
				val.Set("MS_Riko_SpawnTime", nowSeconds2);
			}
			if (val.GetInt("MS_Riko_VfxPlayed", -1) < 0)
			{
				val.Set("MS_Riko_VfxPlayed", 0);
			}
			if (val.GetInt("MS_Riko_FinalDestroyCounted", -1) < 0)
			{
				val.Set("MS_Riko_FinalDestroyCounted", 0);
			}
		}
		catch
		{
		}
	}

	private static void HandleContainerClosed(Container container)
	{
		//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)container == (Object)null || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
		{
			return;
		}
		BuildDefCache();
		GameObject gameObject = ((Component)container).gameObject;
		if ((Object)(object)gameObject == (Object)null)
		{
			return;
		}
		string prefabName = Utils.GetPrefabName(((Object)gameObject).name);
		if (!DefByPrefab.TryGetValue(prefabName, out var value))
		{
			return;
		}
		ZNetView component = gameObject.GetComponent<ZNetView>();
		if ((Object)(object)component == (Object)null || !component.IsValid())
		{
			return;
		}
		Inventory inventory = container.GetInventory();
		if (inventory == null || inventory.NrOfItems() != 0)
		{
			return;
		}
		ZDO val = null;
		try
		{
			val = component.GetZDO();
		}
		catch
		{
		}
		if (val == null)
		{
			return;
		}
		long nowSeconds = GetNowSeconds();
		long num = ((value.DestroyDelay > 0f) ? Mathf.CeilToInt(value.DestroyDelay) : 0);
		long num2 = nowSeconds + num;
		bool flag = TryMarkKilledIfNeeded(val, prefabName, num2, "ContainerEmpty", component);
		LogLife($"server ContainerEmpty MARK_KILLED prefab={prefabName} uid={val.m_uid} delay={value.DestroyDelay:0.00} destroyAt={num2} now={nowSeconds} changed={flag}");
		if (flag)
		{
			TriggerLoadedRikoVanishWithFx(component, prefabName, "ContainerEmpty");
			if (num <= 0)
			{
				DestroyKilledLoadedRiko(component, prefabName, "ContainerEmpty delay=0", playFx: false);
			}
		}
	}

	private static void ApplyContainerConfigToPrefab(LivingContainerDef def, GameObject prefab)
	{
		if (def == null || (Object)(object)prefab == (Object)null || !LivingContainerConfig.RikoConfigs.TryGetValue(GetRikoId(def), out var value))
		{
			return;
		}
		Container component = prefab.GetComponent<Container>();
		if ((Object)(object)component == (Object)null)
		{
			return;
		}
		PrefabContainerTuning prefabContainerTuning = default(PrefabContainerTuning);
		prefabContainerTuning.Width = Mathf.Max(1, value.ContainerWidth.Value);
		prefabContainerTuning.Height = Mathf.Max(1, value.ContainerHeight.Value);
		prefabContainerTuning.LootMin = Mathf.Max(0, value.ContainerLootMin.Value);
		prefabContainerTuning.LootMax = Mathf.Max(0, value.ContainerLootMax.Value);
		PrefabContainerTuning prefabContainerTuning2 = prefabContainerTuning;
		if (prefabContainerTuning2.LootMax < prefabContainerTuning2.LootMin)
		{
			prefabContainerTuning2.LootMax = prefabContainerTuning2.LootMin;
		}
		if (!AppliedPrefabTuning.TryGetValue(def.Prefab, out var value2) || !value2.Equals(prefabContainerTuning2))
		{
			component.m_width = prefabContainerTuning2.Width;
			component.m_height = prefabContainerTuning2.Height;
			if (component.m_defaultItems != null)
			{
				component.m_defaultItems.m_dropMin = prefabContainerTuning2.LootMin;
				component.m_defaultItems.m_dropMax = prefabContainerTuning2.LootMax;
			}
			component.m_autoDestroyEmpty = false;
			AppliedPrefabTuning[def.Prefab] = prefabContainerTuning2;
		}
	}

	[HarmonyPrefix]
	[HarmonyPatch(typeof(Container), "AddDefaultItems")]
	private static void Container_AddDefaultItems_Prefix(Container __instance)
	{
		//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
		//IL_0206: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)__instance == (Object)null || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
		{
			return;
		}
		ZNetView component = ((Component)__instance).GetComponent<ZNetView>();
		if ((Object)(object)component == (Object)null || !component.IsValid() || !component.IsOwner())
		{
			return;
		}
		string prefabName = Utils.GetPrefabName(((Object)((Component)component).gameObject).name);
		BuildDefCache();
		if (!DefByPrefab.ContainsKey(prefabName) || !LivingContainerConfig.RikoConfigs.TryGetValue(GetRikoId(prefabName), out var value))
		{
			return;
		}
		DropTable defaultItems = __instance.m_defaultItems;
		if (defaultItems == null)
		{
			return;
		}
		string text = value.LootTable?.Value ?? string.Empty;
		if (string.IsNullOrWhiteSpace(text))
		{
			return;
		}
		string[] array = text.Split(new char[2] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
		if (defaultItems.m_drops == null)
		{
			defaultItems.m_drops = new List<DropData>();
		}
		defaultItems.m_drops.Clear();
		string[] array2 = array;
		for (int i = 0; i < array2.Length; i++)
		{
			string text2 = array2[i].Trim();
			if (string.IsNullOrWhiteSpace(text2) || text2.StartsWith("#") || text2.StartsWith("//"))
			{
				continue;
			}
			string[] array3 = text2.Split(new char[1] { ',' });
			if (array3.Length < 4)
			{
				continue;
			}
			string text3 = array3[0].Trim();
			if (int.TryParse(array3[1].Trim(), out var result) && int.TryParse(array3[2].Trim(), out var result2) && float.TryParse(array3[3].Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out var result3))
			{
				GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(text3);
				if (!((Object)(object)itemPrefab == (Object)null))
				{
					DropData val = default(DropData);
					val.m_item = itemPrefab;
					val.m_stackMin = Mathf.Max(1, result);
					val.m_stackMax = Mathf.Max(result, result2);
					val.m_weight = Mathf.Max(0f, result3);
					val.m_dontScale = false;
					DropData item = val;
					defaultItems.m_drops.Add(item);
				}
			}
		}
	}

	private static void AttachPinComponent(GameObject go, LivingContainerDef def)
	{
		if (!((Object)(object)go == (Object)null) && def != null && !string.IsNullOrEmpty(def.PinSprite))
		{
			LivingContainerPinComponent livingContainerPinComponent = go.GetComponent<LivingContainerPinComponent>();
			if ((Object)(object)livingContainerPinComponent == (Object)null)
			{
				livingContainerPinComponent = go.AddComponent<LivingContainerPinComponent>();
			}
			livingContainerPinComponent.PinSprite = def.PinSprite;
			livingContainerPinComponent.PinText = def.PinText ?? "";
			livingContainerPinComponent.PinAnimate = def.PinAnimate;
			livingContainerPinComponent.PinDoubleSize = def.PinDoubleSize;
		}
	}

	private static bool SpawnVfx(LivingContainerDef def, GameObject go)
	{
		//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_007c: Unknown result type (might be due to invalid IL or missing references)
		if (def == null || string.IsNullOrEmpty(def.VfxPrefab))
		{
			return false;
		}
		if ((Object)(object)ZNetScene.instance == (Object)null || (Object)(object)go == (Object)null)
		{
			return false;
		}
		GameObject prefab = ZNetScene.instance.GetPrefab(def.VfxPrefab);
		if ((Object)(object)prefab == (Object)null)
		{
			LogLife("server VFX MISSING prefab=" + def.VfxPrefab);
			return false;
		}
		try
		{
			if ((Object)(object)prefab.GetComponent<ZNetView>() != (Object)null)
			{
				bool flag = (Object)(object)Object.Instantiate<GameObject>(prefab, go.transform.position, go.transform.rotation) != (Object)null;
				LogLife($"server VFX NET_SPAWN prefab={def.VfxPrefab} ok={flag}");
				return flag;
			}
			Object.Instantiate<GameObject>(prefab, go.transform.position, go.transform.rotation);
			LogLife("server VFX LOCAL_SPAWN prefab=" + def.VfxPrefab + " ok=true");
			return true;
		}
		catch (Exception ex)
		{
			LogLife("server VFX SPAWN_FAIL prefab=" + def.VfxPrefab + " error=" + ex.GetType().Name);
			return false;
		}
	}

	private static void FixSpawnInsideGeometry(GameObject go)
	{
		if (!((Object)(object)go == (Object)null))
		{
			RikoSpawnStabilizer rikoSpawnStabilizer = go.GetComponent<RikoSpawnStabilizer>();
			if ((Object)(object)rikoSpawnStabilizer == (Object)null)
			{
				rikoSpawnStabilizer = go.AddComponent<RikoSpawnStabilizer>();
			}
			rikoSpawnStabilizer.Init();
		}
	}

	private static void StabilizeOnce(GameObject go)
	{
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_008b: Unknown result type (might be due to invalid IL or missing references)
		//IL_008c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0096: Unknown result type (might be due to invalid IL or missing references)
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0074: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)go == (Object)null))
		{
			Vector3 position = go.transform.position;
			go.transform.position = position + Vector3.up * 0.35f;
			if (TryFindSolidBelow(go.transform.position + Vector3.up * 0.25f, 8f, out var ground))
			{
				go.transform.position = ground + Vector3.up * 0.03f;
			}
			else
			{
				go.transform.position = position + Vector3.up * 0.1f;
			}
			if (IsBodyOverlapping(go.transform.position))
			{
				Transform transform = go.transform;
				transform.position += Vector3.up * 0.6f;
			}
		}
	}

	private static bool TryFindSolidBelow(Vector3 origin, float maxDist, out Vector3 ground)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_0055: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: Unknown result type (might be due to invalid IL or missing references)
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0087: Unknown result type (might be due to invalid IL or missing references)
		//IL_008c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0091: Unknown result type (might be due to invalid IL or missing references)
		ground = origin;
		RaycastHit[] array = Physics.RaycastAll(origin, Vector3.down, maxDist, SolidMask, (QueryTriggerInteraction)1);
		if (array == null || array.Length == 0)
		{
			return false;
		}
		Array.Sort(array, (RaycastHit a, RaycastHit b) => ((RaycastHit)(ref a)).distance.CompareTo(((RaycastHit)(ref b)).distance));
		RaycastHit[] array2 = array;
		for (int i = 0; i < array2.Length; i++)
		{
			RaycastHit val = array2[i];
			if (!((Object)(object)((RaycastHit)(ref val)).collider == (Object)null) && !((RaycastHit)(ref val)).collider.isTrigger)
			{
				ground = ((RaycastHit)(ref val)).point + ((RaycastHit)(ref val)).normal * 0.02f;
				return true;
			}
		}
		return false;
	}

	private static bool IsBodyOverlapping(Vector3 basePos)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		Vector3 val = basePos + Vector3.up * 0.25f;
		Vector3 val2 = basePos + Vector3.up * 1.05f;
		float num = 0.2f;
		return Physics.CheckCapsule(val, val2, num, SolidMask, (QueryTriggerInteraction)1);
	}

	private static Vector3 PickPoint(Vector3 o, float min, float max)
	{
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		float num = Random.Range(min, max);
		Vector2 insideUnitCircle = Random.insideUnitCircle;
		Vector2 val = ((Vector2)(ref insideUnitCircle)).normalized * num;
		return new Vector3(o.x + val.x, o.y + 2f, o.z + val.y);
	}

	private static void BuildDefCache()
	{
		if (DefByPrefab.Count <= 0)
		{
			LivingContainerDef[] defs = Defs;
			foreach (LivingContainerDef livingContainerDef in defs)
			{
				ApplyConfig(livingContainerDef);
				DefByPrefab[livingContainerDef.Prefab] = livingContainerDef;
			}
		}
	}

	private static void RefreshDefsFromConfig()
	{
		for (int i = 0; i < Defs.Length; i++)
		{
			ApplyConfig(Defs[i]);
		}
	}

	private static void ApplyConfig(LivingContainerDef def)
	{
		if (def != null && LivingContainerConfig.RikoConfigs.TryGetValue(GetRikoId(def), out var value))
		{
			def.CheckInterval = Mathf.Max(1f, value.CheckInterval.Value);
			def.SpawnChance = Mathf.Clamp01(value.SpawnChance.Value);
			def.MaxInWorld = Mathf.Max(0, value.MaxInWorld.Value);
			def.MinDistance = Mathf.Max(0f, value.MinDistance.Value);
			def.MaxDistance = Mathf.Max(def.MinDistance, value.MaxDistance.Value);
			def.MinAltitude = value.MinAltitude.Value;
			def.MaxAltitude = Mathf.Max(def.MinAltitude, value.MaxAltitude.Value);
		}
	}

	private static string GetRikoId(LivingContainerDef def)
	{
		if (def == null)
		{
			return string.Empty;
		}
		return GetRikoId(def.Prefab);
	}

	private static string GetRikoId(string prefabName)
	{
		string text = prefabName ?? string.Empty;
		if (!text.StartsWith("EncounterCreatureRiko", StringComparison.Ordinal) || !text.EndsWith("DO", StringComparison.Ordinal))
		{
			return text;
		}
		return text.Substring("EncounterCreatureRiko".Length, text.Length - "EncounterCreatureRiko".Length - "DO".Length);
	}

	private static long GetNowSeconds()
	{
		try
		{
			if ((Object)(object)ZNet.instance != (Object)null)
			{
				long num = ZNet.instance.GetTime().Ticks / 10000000;
				if (num > 0)
				{
					return num;
				}
			}
		}
		catch
		{
		}
		return DateTime.UtcNow.Ticks / 10000000;
	}
}
[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
[HarmonyPatch(typeof(RandomSpeak), "Speak")]
public static class RandomSpeakUpgrade
{
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	private struct WeightedText
	{
		public string text;

		public float weight;

		public WeightedText(string text, float weight)
		{
			this.text = text;
			this.weight = weight;
		}
	}

	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
	private class RikoPrefabConfig
	{
		public bool useGreeting;

		public bool useGeneral;

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(1)]
		public WeightedText[] localTexts;
	}

	private const string ZdoGreetingKey = "riko_greeted";

	private const string ZdoCycleKey = "riko_cycle";

	private const string ZdoCycleIndexKey = "riko_cycle_index";

	private static readonly WeightedText[] GeneralTexts = new WeightedText[12]
	{
		new WeightedText("$encounter_riko_general_text_1_DO", 0.05f),
		new WeightedText("$encounter_riko_general_text_2_DO", 0.05f),
		new WeightedText("$encounter_riko_general_text_3_DO", 0.05f),
		new WeightedText("$encounter_riko_general_text_4_DO", 0.05f),
		new WeightedText("$encounter_riko_general_text_5_DO", 0.05f),
		new WeightedText("$encounter_riko_general_text_6_DO", 0.05f),
		new WeightedText("$encounter_riko_general_text_7_DO", 0.05f),
		new WeightedText("$encounter_riko_general_text_8_DO", 0.05f),
		new WeightedText("$encounter_riko_general_text_9_DO", 0.05f),
		new WeightedText("$encounter_riko_general_text_10_DO", 0.05f),
		new WeightedText("$encounter_riko_general_text_11_DO", 0.05f),
		new WeightedText("$encounter_riko_general_text_12_DO", 0.05f)
	};

	private static readonly WeightedText[] BlackforestLocalTexts = new WeightedText[5]
	{
		new WeightedText("$encounter_riko_blackforest_text_1_DO", 1f),
		new WeightedText("$encounter_riko_blackforest_text_2_DO", 0.8f),
		new WeightedText("$encounter_riko_blackforest_text_3_DO", 0.8f),
		new WeightedText("$encounter_riko_blackforest_text_4_DO", 0.8f),
		new WeightedText("$encounter_riko_blackforest_text_5_DO", 0.8f)
	};

	private static readonly WeightedText[] SwampLocalTexts = new WeightedText[5]
	{
		new WeightedText("$encounter_riko_swamp_text_1_DO", 1f),
		new WeightedText("$encounter_riko_swamp_text_2_DO", 0.8f),
		new WeightedText("$encounter_riko_swamp_text_3_DO", 0.8f),
		new WeightedText("$encounter_riko_swamp_text_4_DO", 0.8f),
		new WeightedText("$encounter_riko_swamp_text_5_DO", 0.8f)
	};

	private static readonly WeightedText[] MountainLocalTexts = new WeightedText[5]
	{
		new WeightedText("$encounter_riko_mountain_text_1_DO", 1f),
		new WeightedText("$encounter_riko_mountain_text_2_DO", 0.8f),
		new WeightedText("$encounter_riko_mountain_text_3_DO", 0.8f),
		new WeightedText("$encounter_riko_mountain_text_4_DO", 0.8f),
		new WeightedText("$encounter_riko_mountain_text_5_DO", 0.8f)
	};

	private static readonly WeightedText[] PlainsLocalTexts = new WeightedText[5]
	{
		new WeightedText("$encounter_riko_plains_text_1_DO", 1f),
		new WeightedText("$encounter_riko_plains_text_2_DO", 0.8f),
		new WeightedText("$encounter_riko_plains_text_3_DO", 0.8f),
		new WeightedText("$encounter_riko_plains_text_4_DO", 0.8f),
		new WeightedText("$encounter_riko_plains_text_5_DO", 0.8f)
	};

	private static readonly WeightedText[] MistlandsLocalTexts = new WeightedText[5]
	{
		new WeightedText("$encounter_riko_mistlands_text_1_DO", 1f),
		new WeightedText("$encounter_riko_mistlands_text_2_DO", 0.8f),
		new WeightedText("$encounter_riko_mistlands_text_3_DO", 0.8f),
		new WeightedText("$encounter_riko_mistlands_text_4_DO", 0.8f),
		new WeightedText("$encounter_riko_mistlands_text_5_DO", 0.8f)
	};

	private static readonly WeightedText[] AshlandsLocalTexts = new WeightedText[5]
	{
		new WeightedText("$encounter_riko_ashlands_text_1_DO", 1f),
		new WeightedText("$encounter_riko_ashlands_text_2_DO", 0.8f),
		new WeightedText("$encounter_riko_ashlands_text_3_DO", 0.8f),
		new WeightedText("$encounter_riko_ashlands_text_4_DO", 0.8f),
		new WeightedText("$encounter_riko_ashlands_text_5_DO", 0.8f)
	};

	private static readonly Dictionary<string, RikoPrefabConfig> PrefabConfigs = new Dictionary<string, RikoPrefabConfig>
	{
		{
			"EncounterCreatureRikoBlackforestDO",
			new RikoPrefabConfig
			{
				useGreeting = true,
				useGeneral = true,
				localTexts = BlackforestLocalTexts
			}
		},
		{
			"EncounterCreatureRikoSwampDO",
			new RikoPrefabConfig
			{
				useGreeting = true,
				useGeneral = true,
				localTexts = SwampLocalTexts
			}
		},
		{
			"EncounterCreatureRikoMountainDO",
			new RikoPrefabConfig
			{
				useGreeting = true,
				useGeneral = true,
				localTexts = MountainLocalTexts
			}
		},
		{
			"EncounterCreatureRikoPlainsDO",
			new RikoPrefabConfig
			{
				useGreeting = true,
				useGeneral = true,
				localTexts = PlainsLocalTexts
			}
		},
		{
			"EncounterCreatureRikoMistlandsDO",
			new RikoPrefabConfig
			{
				useGreeting = true,
				useGeneral = true,
				localTexts = MistlandsLocalTexts
			}
		},
		{
			"EncounterCreatureRikoAshlandsDO",
			new RikoPrefabConfig
			{
				useGreeting = true,
				useGeneral = true,
				localTexts = AshlandsLocalTexts
			}
		}
	};

	private static bool Prefix(RandomSpeak __instance)
	{
		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_013b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0146: Unknown result type (might be due to invalid IL or missing references)
		//IL_0164: Unknown result type (might be due to invalid IL or missing references)
		if (!((MonoBehaviour)__instance).IsInvoking())
		{
			((MonoBehaviour)__instance).InvokeRepeating("Speak", Random.Range(0f, __instance.m_interval), __instance.m_interval);
		}
		string prefabName = Utils.GetPrefabName(((Component)__instance).gameObject);
		if (!PrefabConfigs.TryGetValue(prefabName, out var value))
		{
			return true;
		}
		if (Random.value > __instance.m_chance)
		{
			return false;
		}
		if ((Object)(object)Player.m_localPlayer == (Object)null)
		{
			return false;
		}
		if (Vector3.Distance(((Component)__instance).transform.position, ((Component)Player.m_localPlayer).transform.position) > __instance.m_triggerDistance)
		{
			return false;
		}
		if (__instance.m_onlyOnItemStand && !Object.op_Implicit((Object)(object)((Component)__instance).gameObject.GetComponentInParent<ItemStand>()))
		{
			return false;
		}
		float dayFraction = EnvMan.instance.GetDayFraction();
		if (!IsTimeAllowed(__instance, dayFraction))
		{
			return false;
		}
		ZNetView component = ((Component)__instance).GetComponent<ZNetView>();
		if ((Object)(object)component == (Object)null || !component.IsValid())
		{
			return false;
		}
		ZDO zDO = component.GetZDO();
		string text;
		if (value.useGreeting && !zDO.GetBool("riko_greeted", false))
		{
			zDO.Set("riko_greeted", true);
			text = value.localTexts[0].text;
		}
		else
		{
			text = GetNextFromCycle(zDO, value);
			if (string.IsNullOrEmpty(text))
			{
				return false;
			}
		}
		__instance.m_speakEffects.Create(((Component)__instance).transform.position, ((Component)__instance).transform.rotation, (Transform)null, 1f, -1);
		Chat.instance.SetNpcText(((Component)__instance).gameObject, __instance.m_offset, __instance.m_cullDistance, __instance.m_ttl, __instance.m_topic, text, __instance.m_useLargeDialog);
		return false;
	}

	private static string GetNextFromCycle(ZDO zdo, RikoPrefabConfig config)
	{
		string text = zdo.GetString("riko_cycle", "");
		int num = zdo.GetInt("riko_cycle_index", 0);
		if (string.IsNullOrEmpty(text))
		{
			text = BuildNewCycle(config);
			num = 0;
		}
		string[] array = text.Split(new char[1] { ',' });
		if (num >= array.Length)
		{
			text = BuildNewCycle(config);
			num = 0;
			array = text.Split(new char[1] { ',' });
		}
		int index = int.Parse(array[num]);
		zdo.Set("riko_cycle_index", num + 1);
		zdo.Set("riko_cycle", text);
		return ResolveTextByIndex(index, config);
	}

	private static string BuildNewCycle(RikoPrefabConfig config)
	{
		List<int> list = new List<int>();
		List<float> list2 = new List<float>();
		for (int i = 1; i < config.localTexts.Length; i++)
		{
			list.Add(i);
			list2.Add(config.localTexts[i].weight);
		}
		if (config.useGeneral)
		{
			for (int j = 0; j < GeneralTexts.Length; j++)
			{
				list.Add(100 + j);
				list2.Add(GeneralTexts[j].weight);
			}
		}
		List<int> list3 = new List<int>();
		while (list.Count > 0)
		{
			float num = 0f;
			foreach (float item in list2)
			{
				num += item;
			}
			float num2 = Random.Range(0f, num);
			float num3 = 0f;
			for (int k = 0; k < list.Count; k++)
			{
				num3 += list2[k];
				if (num2 <= num3)
				{
					list3.Add(list[k]);
					list.RemoveAt(k);
					list2.RemoveAt(k);
					break;
				}
			}
		}
		StringBuilder stringBuilder = new StringBuilder();
		for (int l = 0; l < list3.Count; l++)
		{
			if (l > 0)
			{
				stringBuilder.Append(",");
			}
			stringBuilder.Append(list3[l]);
		}
		return stringBuilder.ToString();
	}

	private static string ResolveTextByIndex(int index, RikoPrefabConfig config)
	{
		if (index >= 100)
		{
			return GeneralTexts[index - 100].text;
		}
		return config.localTexts[index].text;
	}

	private static bool IsTimeAllowed(RandomSpeak rs, float dayFraction)
	{
		if (!rs.m_invertTod)
		{
			if (!(dayFraction < rs.m_minTOD))
			{
				return !(dayFraction > rs.m_maxTOD);
			}
			return false;
		}
		if (!(dayFraction > rs.m_minTOD))
		{
			return !(dayFraction < rs.m_maxTOD);
		}
		return false;
	}
}
[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
internal static class SSU_Log
{
	private static readonly ManualLogSource _log = Logger.CreateLogSource("SlingshotSecondaryUnlock");

	public static void Info(string s)
	{
		_log.LogInfo((object)s);
	}

	public static void Err(string s)
	{
		_log.LogError((object)s);
	}
}
[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
internal static class SSU_Whitelist
{
	private static readonly string[] _names;

	internal static readonly HashSet<string> Names;

	internal static readonly HashSet<int> NameHashes;

	static SSU_Whitelist()
	{
		_names = new string[1] { "BowFrostcallerIceDO" };
		Names = new HashSet<string>(StringComparer.Ordinal);
		NameHashes = new HashSet<int>();
		string[] names = _names;
		foreach (string text in names)
		{
			Names.Add(text);
			NameHashes.Add(StringExtensionMethods.GetStableHashCode(text));
		}
	}

	public static bool Match(string prefabName)
	{
		if (string.IsNullOrEmpty(prefabName))
		{
			return false;
		}
		if (Names.Contains(prefabName))
		{
			return true;
		}
		return NameHashes.Contains(StringExtensionMethods.GetStableHashCode(prefabName));
	}
}
[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
internal static class SSU_State
{
	private static readonly Dictionary<int, bool> _secondaryDrawActive = new Dictionary<int, bool>();

	private static int Key(Player p)
	{
		if (!Object.op_Implicit((Object)(object)p))
		{
			return 0;
		}
		return ((Object)p).GetInstanceID();
	}

	public static bool IsSecondaryDrawActive(Player p)
	{
		int key = Key(p);
		bool value;
		return _secondaryDrawActive.TryGetValue(key, out value) && value;
	}

	public static void SetSecondaryDrawActive(Player p, bool active)
	{
		int key = Key(p);
		if (active)
		{
			_secondaryDrawActive[key] = true;
		}
		else
		{
			_secondaryDrawActive.Remove(key);
		}
	}
}
[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
internal static class SSU_Util
{
	private static readonly BindingFlags InstAll = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;

	private static readonly MethodInfo MI_UpdateWeaponLoading = typeof(Player).GetMethod("UpdateWeaponLoading", InstAll, null, new Type[2]
	{
		typeof(ItemData),
		typeof(float)
	}, null);

	private static readonly MethodInfo MI_UpdateAttackBowDraw = typeof(Player).GetMethod("UpdateAttackBowDraw", InstAll, null, new Type[2]
	{
		typeof(ItemData),
		typeof(float)
	}, null);

	private static readonly MethodInfo MI_InPlaceMode = typeof(Player).GetMethod("InPlaceMode", InstAll, null, Type.EmptyTypes, null);

	public static string GetPrefabName(ItemData item)
	{
		if (item == null)
		{
			return null;
		}
		if ((Object)(object)item.m_dropPrefab != (Object)null)
		{
			return ((Object)item.m_dropPrefab).name;
		}
		try
		{
			ObjectDB instance = ObjectDB.instance;
			if ((Object)(object)instance != (Object)null)
			{
				foreach (GameObject item2 in instance.m_items)
				{
					if (Object.op_Implicit((Object)(object)item2) && item2.GetComponent<ItemDrop>()?.m_itemData?.m_shared == item.m_shared)
					{
						return ((Object)item2).name;
					}
				}
			}
		}
		catch
		{
		}
		return null;
	}

	private static FieldInfo FindField(Type t, string name)
	{
		while (t != null)
		{
			FieldInfo field = t.GetField(name, InstAll);
			if (field != null)
			{
				return field;
			}
			t = t.BaseType;
		}
		return null;
	}

	public static T GetField<[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)] T>(object obj, string name)
	{
		if (obj == null)
		{
			return default(T);
		}
		FieldInfo fieldInfo = FindField(obj.GetType(), name);
		if (fieldInfo == null)
		{
			return default(T);
		}
		object value = fieldInfo.GetValue(obj);
		if (value is T)
		{
			return (T)value;
		}
		try
		{
			return (T)Convert.ChangeType(value, typeof(T));
		}
		catch
		{
			return default(T);
		}
	}

	public static void SetField(object obj, string name, object value)
	{
		if (obj != null)
		{
			FieldInfo fieldInfo = FindField(obj.GetType(), name);
			if (!(fieldInfo == null))
			{
				fieldInfo.SetValue(obj, value);
			}
		}
	}

	private static bool CallBoolNoArgs(object obj, MethodInfo mi)
	{
		if (obj == null || mi == null)
		{
			return false;
		}
		try
		{
			object obj2 = mi.Invoke(obj, Array.Empty<object>());
			bool flag = default(bool);
			int num;
			if (obj2 is bool)
			{
				flag = (bool)obj2;
				num = 1;
			}
			else
			{
				num = 0;
			}
			return (byte)((uint)num & (flag ? 1u : 0u)) != 0;
		}
		catch
		{
			return false;
		}
	}

	public static bool InPlaceMode(Player p)
	{
		return CallBoolNoArgs(p, MI_InPlaceMode);
	}

	public static void CallUpdateWeaponLoading(Player p, ItemData weapon, float dt)
	{
		if ((Object)(object)p == (Object)null || MI_UpdateWeaponLoading == null)
		{
			return;
		}
		try
		{
			MI_UpdateWeaponLoading.Invoke(p, new object[2] { weapon, dt });
		}
		catch
		{
		}
	}

	public static void CallUpdateAttackBowDraw(Player p, ItemData weapon, float dt)
	{
		if ((Object)(object)p == (Object)null || MI_UpdateAttackBowDraw == null)
		{
			return;
		}
		try
		{
			MI_UpdateAttackBowDraw.Invoke(p, new object[2] { weapon, dt });
		}
		catch
		{
		}
	}

	public static void HandleLoopingAbort(Player p)
	{
		object field = GetField<object>(p, "m_currentAttack");
		if (field == null || !GetField<bool>(field, "m_loopingAttack"))
		{
			return;
		}
		bool field2 = GetField<bool>(p, "m_currentAttackIsSecondary");
		bool field3 = GetField<bool>(p, "m_attackHold");
		bool field4 = GetField<bool>(p, "m_secondaryAttackHold");
		if (field2 ? field4 : field3)
		{
			return;
		}
		MethodInfo method = field.GetType().GetMethod("Abort", InstAll, null, Type.EmptyTypes, null);
		if (method == null)
		{
			return;
		}
		try
		{
			method.Invoke(field, Array.Empty<object>());
		}
		catch
		{
		}
	}

	public static void HandleSlingshotAttackInput(Player p, float dt)
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Invalid comparison between Unknown and I4
		if ((Object)(object)p == (Object)null)
		{
			return;
		}
		ItemData currentWeapon = ((Humanoid)p).GetCurrentWeapon();
		if (currentWeapon == null || currentWeapon.m_shared == null || (int)currentWeapon.m_shared.m_itemType != 4 || !currentWeapon.m_shared.m_attack.m_bowDraw || !SSU_Whitelist.Match(GetPrefabName(currentWeapon)) || InPlaceMode(p))
		{
			return;
		}
		CallUpdateWeaponLoading(p, currentWeapon, dt);
		bool field = GetField<bool>(p, "m_secondaryAttackHold");
		bool field2 = GetField<bool>(p, "m_attackHold");
		bool flag = currentWeapon.m_shared.m_secondaryAttack != null;
		bool flag2;
		if (SSU_State.IsSecondaryDrawActive(p))
		{
			flag2 = true;
		}
		else
		{
			flag2 = flag && field && !field2;
			if (flag2)
			{
				SSU_State.SetSecondaryDrawActive(p, active: true);
			}
		}
		if (flag2)
		{
			SharedData shared = currentWeapon.m_shared;
			Attack attack = shared.m_attack;
			Attack secondaryAttack = shared.m_secondaryAttack;
			if (secondaryAttack == null)
			{
				CallUpdateAttackBowDraw(p, currentWeapon, dt);
			}
			else
			{
				bool field3 = GetField<bool>(p, "m_attackHold");
				try
				{
					shared.m_attack = secondaryAttack;
					SetField(p, "m_attackHold", field);
					CallUpdateAttackBowDraw(p, currentWeapon, dt);
				}
				finally
				{
					shared.m_attack = attack;
					SetField(p, "m_attackHold", field3);
				}
				float field4 = GetField<float>(p, "m_attackDrawTime");
				if (!field && field4 <= 0f)
				{
					SSU_State.SetSecondaryDrawActive(p, active: false);
				}
			}
		}
		else
		{
			CallUpdateAttackBowDraw(p, currentWeapon, dt);
		}
		HandleLoopingAbort(p);
	}
}
[HarmonyPatch(typeof(Player), "PlayerAttackInput")]
internal static class SSU_PlayerAttackInput_Patch
{
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	private static bool Prefix(Player __instance, float dt)
	{
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: Invalid comparison between Unknown and I4
		try
		{
			if ((Object)(object)__instance != (Object)(object)Player.m_localPlayer)
			{
				return true;
			}
			ItemData currentWeapon = ((Humanoid)__instance).GetCurrentWeapon();
			if (currentWeapon == null || currentWeapon.m_shared == null)
			{
				return true;
			}
			if ((int)currentWeapon.m_shared.m_itemType != 4)
			{
				return true;
			}
			if (!SSU_Whitelist.Match(SSU_Util.GetPrefabName(currentWeapon)))
			{
				return true;
			}
			SSU_Util.HandleSlingshotAttackInput(__instance, dt);
			return false;
		}
		catch (Exception ex)
		{
			SSU_Log.Err("SlingshotSecondaryUnlock.PlayerAttackInput error: " + ex.GetType().Name + ": " + ex.Message);
			return true;
		}
	}
}
namespace SharedTools
{
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	public static class ZDOCleanup
	{
		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		public static class ZDOCleanupPatch
		{
			private static void Postfix(ZNetScene __instance)
			{
				((MonoBehaviour)__instance).StartCoroutine(DelayedCleanup());
			}

			private static IEnumerator DelayedCleanup()
			{
				yield return (object)new WaitForSeconds(1f);
				RunCleanup();
			}
		}

		private static readonly string[] _oldProjectilePrefabs = new string[3] { "projectile_stormcaller_staff_sphere_DO", "projectile_frostcaller_staff_shard_DO", "projectile_lightcaller_staff_sphere_DO" };

		public static void RunCleanup()
		{
			if ((Object)(object)ZNetScene.instance == (Object)null || ZDOMan.instance == null)
			{
				return;
			}
			int num = 0;
			int num2 = 0;
			foreach (ZDO item in ZDOMan.instance.m_objectsByID.Values.ToList())
			{
				GameObject prefab = ZNetScene.instance.GetPrefab(item.m_prefab);
				if ((Object)(object)prefab == (Object)null)
				{
					ZDOMan.instance.DestroyZDO(item);
					num2++;
				}
				else if (_oldProjectilePrefabs.Contains(((Object)prefab).name))
				{
					ZDOMan.instance.DestroyZDO(item);
					num++;
				}
			}
			if (num > 0 || num2 > 0)
			{
				ZLog.Log((object)$"ZDOCleanup: Cleaned {num} old projectiles and {num2} orphan ZDO(s).");
			}
			else
			{
				ZLog.Log((object)"ZDOCleanup: No old or orphan ZDOs found.");
			}
		}
	}
}
namespace PieceManager
{
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[PublicAPI]
	public static class MaterialReplacer
	{
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>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()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			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((MethodBase)AccessTools.DeclaredMethod(typeof(ZoneSystem), "Start", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(MaterialReplacer), "ReplaceAllMaterialsWithOriginal", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		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 val in array)
			{
				OriginalMaterials[((Object)val).name] = val;
			}
		}

		[HarmonyPriority(700)]
		private static void ReplaceAllMaterialsWithOriginal()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			if ((int)SystemInfo.graphicsDeviceType == 4 || 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 val in array)
			{
				IEnumerable<Shader> enumerable3;
				try
				{
					IEnumerable<Shader> enumerable2;
					if (!val.isStreamedSceneAssetBundle || !Object.op_Implicit((Object)(object)val))
					{
						IEnumerable<Shader> enumerable = val.LoadAllAssets<Shader>();
						enumerable2 = enumerable;
					}
					else
					{
						enumerable2 = from shader in ((IEnumerable<string>)val.GetAllAssetNames()).Select((Func<string, Shader>)val.LoadAsset<Shader>)
							where (Object)(object)shader != (Object)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>(true);
			foreach (Renderer obj in componentsInChildren)
			{
				Material[] sharedMaterials = obj.sharedMaterials.Select([<702532f4-32dc-46a6-8d9a-cabd38c9424b>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 (!((Object)originalMaterial).name.StartsWith(text, StringComparison.Ordinal))
			{
				return originalMaterial;
			}
			string text2 = ((Object)originalMaterial).name.Replace(" (Instance)", "").Replace(text, "");
			if (OriginalMaterials.TryGetValue(text2, out var value))
			{
				return value;
			}
			Debug.LogWarning((object)("No suitable material found to replace: " + text2));
			return originalMaterial;
		}

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

		private static Shader GetShaderForType(Shader orig, ShaderType shaderType, string originalShaderName)
		{
			return (Shader)(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, ((Object)(object)FindShaderWithName(orig, originalShaderName) != (Object)null) ? originalShaderName : "ToonDeferredShading2017"), 
				_ => FindShaderWithName(orig, "Standard"), 
			});
		}

		public static Shader FindShaderWithName(Shader origShader, string name)
		{
			foreach (Shader cachedShader in CachedShaders)
			{
				if (((Object)cachedShader).name == name)
				{
					return cachedShader;
				}
			}
			return origShader;
		}
	}
	[PublicAPI]
	public 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
	}
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	public class InternalName : Attribute
	{
		public readonly string internalName;

		public InternalName(string internalName)
		{
			this.internalName = internalName;
		}
	}
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[PublicAPI]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	public 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
			});
		}
	}
	public struct ExtensionConfig
	{
		public CraftingTable Table;

		public float maxStationDistance;

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)]
		public string custom;
	}
	[PublicAPI]
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	public 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
			});
		}
	}
	public struct CraftingStationConfig
	{
		public CraftingTable Table;

		public int level;

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)]
		public string custom;
	}
	[PublicAPI]
	public enum BuildPieceCategory
	{
		Misc = 0,
		Crafting = 1,
		BuildingWorkbench = 2,
		BuildingStonecutter = 3,
		Furniture = 4,
		All = 100,
		Custom = 99
	}
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	[PublicAPI]
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	public 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
			});
		}
	}
	public struct Requirement
	{
		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(1)]
		public string itemName;

		public int amount;

		public bool recover;
	}
	public 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;
	}
	[PublicAPI]
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	public 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;
		}
	}
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	[PublicAPI]
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	public class PieceTool
	{
		public readonly HashSet<string> Tools = new HashSet<string>();

		public void Add(string tool)
		{
			Tools.Add(tool);
		}
	}
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[PublicAPI]
	public class BuildPiece
	{
		[<5ea91132-7291-4072-bba1-fdb04647c6e6>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;
		}

		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		private class ConfigurationManagerAttributes
		{
			[UsedImplicitly]
			public int? Order;

			[UsedImplicitly]
			public bool? Browsable;

			[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)]
			[UsedImplicitly]
			public string Category;

			[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(new byte[] { 2, 1 })]
			[UsedImplicitly]
			public Action<ConfigEntryBase> CustomDrawer;
		}

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>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([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (string r) =>
				{
					string[] array = r.Split(new char[1] { ':' });
					Requirement result = default(Requirement);
					result.itemName = array[0];
					result.amount = ((array.Length <= 1 || !int.TryParse(array[1], out var result2)) ? 1 : result2);
					bool result3 = default(bool);
					result.recover = array.Length <= 2 || !bool.TryParse(array[2], out result3) || result3;
					return result;
				}).ToList();
			}

			public override string ToString()
			{
				return string.Join(",", Reqs.Select([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (Requirement r) => $"{r.itemName}:{r.amount}:{r.recover}"));
			}

			[return: <5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)]
			public static ItemDrop fetchByName(ObjectDB objectDB, string name)
			{
				GameObject itemPrefab = objectDB.GetItemPrefab(name);
				ItemDrop obj = ((itemPrefab != null) ? itemPrefab.GetComponent<ItemDrop>() : null);
				if ((Object)(object)obj == (Object)null)
				{
					Debug.LogWarning((object)(((!string.IsNullOrWhiteSpace(((Object)plugin).name)) ? ("[" + ((Object)plugin).name + "]") : "") + " The required item '" + name + "' does not exist."));
				}
				return obj;
			}

			public static Requirement[] toPieceReqs(SerializedRequirements craft)
			{
				return craft.Reqs.Where((Requirement r) => r.itemName != "").ToDictionary((Func<Requirement, string>)([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (Requirement r) => r.itemName), (Func<Requirement, Requirement>)([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (Requirement r) =>
				{
					//IL_000c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0011: Unknown result type (might be due to invalid IL or missing references)
					//IL_001d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0024: Unknown result type (might be due to invalid IL or missing references)
					//IL_0031: Expected O, but got Unknown
					ItemDrop val = ResItem(r);
					return (val != null) ? new Requirement
					{
						m_amount = r.amount,
						m_resItem = val,
						m_recover = r.recover
					} : ((Requirement)null);
				})).Values.Where([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (Requirement v) => v != null).ToArray();
				[<702532f4-32dc-46a6-8d9a-cabd38c9424b>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<ItemConversion> conversions = new List<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;

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)]
		[Description("Specifies a config entry which toggles whether a recipe is active.")]
		public ConfigEntryBase RecipeIsActive;

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)]
		private LocalizeKey _name;

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)]
		private LocalizeKey _description;

		internal string[] activeTools;

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)]
		private static object configManager;

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)]
		private static Localization _english;

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)]
		internal static BaseUnityPlugin _plugin = null;

		private static bool hasConfigSync = true;

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>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_" + ((Object)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_" + ((Object)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
			{
				//IL_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a9: Expected O, but got Unknown
				if (_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((Type)source.First([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (TypeInfo t) => t.IsClass && typeof(BaseUnityPlugin).IsAssignableFrom(t)));
				return _plugin;
			}
		}

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)]
		private static object configSync
		{
			[<702532f4-32dc-46a6-8d9a-cabd38c9424b>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)
		{
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: Expected O, but got Unknown
			//IL_0337: Unknown result type (might be due to invalid IL or missing references)
			//IL_0341: Expected O, but got Unknown
			//IL_03d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03af: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0428: Unknown result type (might be due to invalid IL or missing references)
			//IL_0432: Expected O, but got Unknown
			//IL_0586: Unknown result type (might be due to invalid IL or missing references)
			//IL_0590: Expected O, but got Unknown
			//IL_0849: Unknown result type (might be due to invalid IL or missing references)
			//IL_0853: Expected O, but got Unknown
			//IL_05f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0600: Expected O, but got Unknown
			//IL_0697: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a1: Expected O, but got Unknown
			//IL_08b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_08c3: Expected O, but got Unknown
			//IL_0ac1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0acb: Expected O, but got Unknown
			//IL_0b5a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b64: Expected O, but got Unknown
			Type configManagerType = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault([<702532f4-32dc-46a6-8d9a-cabd38c9424b>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 = (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 pieceConfig2 = (pieceConfigs[piece] = new PieceConfig());
				PieceConfig cfg = pieceConfig2;
				Piece piecePrefab2 = piece.Prefab.GetComponent<Piece>();
				string pieceName = piecePrefab2.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.", (AcceptableValueBase)null, new object[1]
				{
					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("", (AcceptableValueBase)null, new object[1] { customTableAttributes }));
				cfg.category.SettingChanged += BuildTableConfigChanged;
				cfg.customCategory.SettingChanged += BuildTableConfigChanged;
				if (cfg.category.Value == BuildPieceCategory.Custom)
				{
					piecePrefab2.m_category = PiecePrefabManager.GetCategory(cfg.customCategory.Value);
				}
				else
				{
					piecePrefab2.m_category = (PieceCategory)cfg.category.Value;
				}
				cfg.tools = config(englishName, "Tools", string.Join(", ", piece.activeTools), new ConfigDescription("Comma separated list of tools where " + localizedName + " is available.", (AcceptableValueBase)null, new object[1] { customTableAttributes }));
				piece.activeTools = (from s in cfg.tools.Value.Split(new char[1] { ',' })
					select s.Trim()).ToArray();
				cfg.tools.SettingChanged += [<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (object _, EventArgs _) =>
				{
					Inventory[] source = (from c in Player.s_players.Select([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (Player p) => ((Humanoid)p).GetInventory()).Concat(from c in 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 Object.op_Implicit((Object)(object)c) && Object.op_Implicit((Object)(object)((Component)c).GetComponent<ZNetView>())
								select c).Concat(ItemDrop.s_instances)
							select new KeyValuePair<string, ItemData>(Utils.GetPrefabName(((Component)i).gameObject), i.m_itemData)).Concat(from i in source.SelectMany([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (Inventory i) => i.GetAllItems())
							select new KeyValuePair<string, ItemData>(((Object)i.m_dropPrefab).name, i))
						where Object.op_Implicit((Object)(object)kv.Value.m_shared.m_buildPieces)
						group kv by kv.Key).ToDictionary([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (IGrouping<string, KeyValuePair<string, ItemData>> g) => g.Key, [<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (IGrouping<string, KeyValuePair<string, ItemData>> g) => g.Select([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (KeyValuePair<string, ItemData> kv) => kv.Value.m_shared.m_buildPieces).Distinct().ToList());
					string[] array5 = piece.activeTools;
					foreach (string key in array5)
					{
						if (dictionary.TryGetValue(key, out var value2))
						{
							foreach (PieceTable item3 in value2)
							{
								item3.m_pieces.Remove(piece.Prefab);
							}
						}
					}
					piece.activeTools = (from s in cfg.tools.Value.Split(new char[1] { ',' })
						select s.Trim()).ToArray();
					if (Object.op_Implicit((Object)(object)ObjectDB.instance))
					{
						array5 = piece.activeTools;
						foreach (string key2 in array5)
						{
							if (dictionary.TryGetValue(key2, out var value3))
							{
								foreach (PieceTable item4 in value3)
								{
									if (!item4.m_pieces.Contains(piece.Prefab))
									{
										item4.m_pieces.Add(piece.Prefab);
									}
								}
							}
						}
						if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && Object.op_Implicit((Object)(object)Player.m_localPlayer.m_buildPieces))
						{
							PiecePrefabManager.CategoryRefreshNeeded = true;
							((Humanoid)Player.m_localPlayer).SetPlaceMode(Player.m_localPlayer.m_buildPieces);
						}
					}
				};
				StationExtension pieceExtensionComp;
				List<ConfigurationManagerAttributes> hideWhenNoneAttributes2;
				if (piece.Extension.ExtensionStations.Count > 0)
				{
					pieceExtensionComp = piece.Prefab.GetOrAddComponent<StationExtension>();
					PieceConfig pieceConfig3 = cfg;
					string group = englishName;
					CraftingTable table = piece.Extension.ExtensionStations.First().Table;
					string text = "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(group, "Extends Station", table, new ConfigDescription(text, (AcceptableValueBase)null, array));
					cfg.customExtentionTable = config(englishName, "Custom Extend Station", piece.Extension.ExtensionStations.First().custom ?? "", new ConfigDescription("", (AcceptableValueBase)null, new object[1] { customTableAttributes }));
					PieceConfig pieceConfig4 = cfg;
					string group2 = englishName;
					float maxStationDistance = piece.Extension.ExtensionStations.First().maxStationDistance;
					string text2 = "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(group2, "Max Station Distance", maxStationDistance, new ConfigDescription(text2, (AcceptableValueBase)null, array2));
					hideWhenNoneAttributes2 = 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;
					hideWhenNoneAttributes2.Add(item);
				}
				List<ConfigurationManagerAttributes> hideWhenNoneAttributes;
				if (piece.Crafting.Stations.Count > 0)
				{
					hideWhenNoneAttributes = new List<ConfigurationManagerAttributes>();
					PieceConfig pieceConfig5 = cfg;
					string group3 = englishName;
					CraftingTable table2 = piece.Crafting.Stations.First().Table;
					string text3 = "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(group3, "Crafting Station", table2, new ConfigDescription(text3, (AcceptableValueBase)null, array3));
					cfg.customTable = config(englishName, "Custom Crafting Station", piece.Crafting.Stations.First().custom ?? "", new ConfigDescription("", (AcceptableValueBase)null, new object[1] { 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;
					hideWhenNoneAttributes.Add(item2);
				}
				cfg.craft = itemConfig("Crafting Costs", new SerializedRequirements(piece.RequiredItems.Requirements).ToString(), "Item costs to craft " + localizedName);
				cfg.craft.SettingChanged += [<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (object _, EventArgs _) =>
				{
					if (Object.op_Implicit((Object)(object)ObjectDB.instance) && (Object)(object)ObjectDB.instance.GetItemPrefab("YmirRemains") != (Object)null)
					{
						Requirement[] resources = SerializedRequirements.toPieceReqs(new SerializedRequirements(cfg.craft.Value));
						piecePrefab2.m_resources = resources;
						Piece[] array4 = Object.FindObjectsOfType<Piece>();
						foreach (Piece val in array4)
						{
							if (val.m_name == pieceName)
							{
								val.m_resources = resources;
							}
						}
					}
				};
				for (int j = 0; j < piece.Conversions.Count; j++)
				{
					string text4 = ((piece.Conversions.Count > 1) ? $"{j + 1}. " : "");
					Conversion conversion = piece.Conversions[j];
					conversion.config = new Conversion.ConversionConfig();
					int index = j;
					conversion.config.input = config(englishName, text4 + "Conversion Input Item", conversion.Input, new ConfigDescription("Conversion input item within " + englishName, (AcceptableValueBase)null, new object[1]
					{
						new ConfigurationManagerAttributes
						{
							Category = localizedName
						}
					}));
					conversion.config.input.SettingChanged += [<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (object _, EventArgs _) =>
					{
						if (index < piece.conversions.Count)
						{
							ObjectDB instance2 = ObjectDB.instance;
							if (instance2 != null)
							{
								ItemDrop from = SerializedRequirements.fetchByName(instance2, conversion.config.input.Value);
								piece.conversions[index].m_from = from;
							}
						}
					};
					conversion.config.output = config(englishName, text4 + "Conversion Output Item", conversion.Output, new ConfigDescription("Conversion output item within " + englishName, (AcceptableValueBase)null, new object[1]
					{
						new ConfigurationManagerAttributes
						{
							Category = localizedName
						}
					}));
					conversion.config.output.SettingChanged += [<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (object _, EventArgs _) =>
					{
						if (index < piece.conversions.Count)
						{
							ObjectDB instance = ObjectDB.instance;
							if (instance != null)
							{
								ItemDrop to = SerializedRequirements.fetchByName(instance, conversion.config.output.Value);
								piece.conversions[index].m_to = to;
							}
						}
					};
				}
				void BuildTableConfigChanged(object o, EventArgs e)
				{
					//IL_0059: Unknown result type (might be due to invalid IL or missing references)
					//IL_0037: Unknown result type (might be due to invalid IL or missing references)
					//IL_003c: Unknown result type (might be due to invalid IL or missing references)
					if (registeredPieces.Count > 0)
					{
						if (cfg.category.Value == BuildPieceCategory.Custom)
						{
							piecePrefab2.m_category = PiecePrefabManager.GetCategory(cfg.customCategory.Value);
						}
						else
						{
							piecePrefab2.m_category = (PieceCategory)cfg.category.Value;
						}
						if (Object.op_Implicit((Object)(object)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)
						{
							StationExtension obj2 = pieceExtensionComp;
							GameObject prefab2 = ZNetScene.instance.GetPrefab(cfg.customExtentionTable.Value);
							obj2.m_craftingStation = ((prefab2 != null) ? prefab2.GetComponent<CraftingStation>() : null);
						}
						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 hideWhenNoneAttributes2)
					{
						item5.Browsable = cfg.extensionTable.Value != CraftingTable.None;
					}
					ReloadConfigDisplay();
					plugin.Config.Save();
				}
				void TableConfigChanged(object o, EventArgs e)
				{
					if (piece.RequiredItems.Requirements.Count > 0)
					{
						switch (cfg.table.Value)
						{
						case CraftingTable.None:
							piecePrefab2.m_craftingStation = null;
							break;
						case CraftingTable.Custom:
						{
							Piece obj = piecePrefab2;
							GameObject prefab = ZNetScene.instance.GetPrefab(cfg.customTable.Value);
							obj.m_craftingStation = ((prefab != null) ? prefab.GetComponent<CraftingStation>() : null);
							break;
						}
						default:
							piecePrefab2.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 hideWhenNoneAttributes)
					{
						item6.Browsable = cfg.table.Value != CraftingTable.None;
					}
					ReloadConfigDisplay();
					plugin.Config.Save();
				}
				ConfigEntry<string> itemConfig(string name, string value, string desc)
				{
					//IL_0054: Unknown result type (might be due to invalid IL or missing references)
					//IL_005e: Expected O, but got Unknown
					ConfigurationManagerAttributes configurationManagerAttributes6 = new ConfigurationManagerAttributes
					{
						CustomDrawer = DrawConfigTable,
						Order = (order -= 1),
						Category = localizedName
					};
					return config(englishName, name, value, new ConfigDescription(desc, (AcceptableValueBase)null, new object[1] { configurationManagerAttributes6 }));
				}
			}
			foreach (BuildPiece registeredPiece3 in registeredPieces)
			{
				ConfigEntryBase enabledCfg = registeredPiece3.RecipeIsActive;
				Piece piecePrefab;
				if (enabledCfg != null)
				{
					piecePrefab = registeredPiece3.Prefab.GetComponent<Piece>();
					ConfigChanged(null, null);
					((object)enabledCfg).GetType().GetEvent("SettingChanged").AddEventHandler(enabledCfg, new EventHandler(ConfigChanged));
				}
				registeredPiece3.InitializeNewRegisteredPiece(registeredPiece3);
				[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(2)]
				void ConfigChanged(object o, EventArgs e)
				{
					piecePrefab.m_enabled = (int)enabledCfg.BoxedValue != 0;
				}
			}
			if (saveOnConfigSet)
			{
				plugin.Config.SaveOnConfigSet = true;
				plugin.Config.Save();
			}
			void ReloadConfigDisplay()
			{
				object obj3 = configManagerType?.GetProperty("DisplayingWindow").GetValue(configManager);
				if (obj3 is bool && (bool)obj3)
				{
					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;
				((object)recipeIsActive).GetType().GetEvent("SettingChanged").AddEventHandler(recipeIsActive, new EventHandler(ConfigChanged));
			}
			void ConfigChanged(object o, EventArgs e)
			{
				if (Object.op_Implicit((Object)(object)ObjectDB.instance) && (Object)(object)ObjectDB.instance.GetItemPrefab("YmirRemains") != (Object)null && cfg != null)
				{
					Requirement[] resources = SerializedRequirements.toPieceReqs(new SerializedRequirements(cfg.craft.Value));
					piecePrefab.m_resources = resources;
					Piece[] array = Object.FindObjectsOfType<Piece>();
					foreach (Piece val in array)
					{
						if (val.m_name == pieceName)
						{
							val.m_resources = resources;
						}
					}
				}
			}
		}

		[HarmonyPriority(700)]
		internal static void Patch_ObjectDBInit(ObjectDB __instance)
		{
			//IL_0441: Unknown result type (might be due to invalid IL or missing references)
			//IL_0446: Unknown result type (might be due to invalid IL or missing references)
			//IL_0479: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b1: Expected O, but got Unknown
			if ((Object)(object)__instance.GetItemPrefab("YmirRemains") == (Object)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 (prefab != null)
						{
							registeredPiece.Prefab.GetComponent<StationExtension>().m_craftingStation = prefab.GetComponent<CraftingStation>();
						}
						else
						{
							Debug.LogWarning((object)("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 (prefab2 != null)
						{
							registeredPiece.Prefab.GetComponent<Piece>().m_craftingStation = prefab2.GetComponent<CraftingStation>();
						}
						else
						{
							Debug.LogWarning((object)("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<ItemConversion>();
				for (int i = 0; i < registeredPiece.Conversions.Count; i++)
				{
					Conversion conversion = registeredPiece.Conversions[i];
					registeredPiece.conversions.Add(new 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 (registeredPiece.conversions[i].m_from != null && 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)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_032a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0331: Expected O, but got Unknown
			//IL_034f: Unknown result type (might be due to invalid IL or missing references)
			//IL_038b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0390: Unknown result type (might be due to invalid IL or missing references)
			//IL_039a: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)prefab == (Object)null) && (prefab.GetComponentsInChildren<Renderer>().Any() || prefab.GetComponentsInChildren<MeshFilter>().Any()))
			{
				Camera component = new GameObject("CameraIcon", new Type[1] { typeof(Camera) }).GetComponent<Camera>();
				component.backgroundColor = Color.clear;
				component.clearFlags = (CameraClearFlags)2;
				((Component)component).transform.position = new Vector3(10000f, 10000f, 10000f);
				((Component)component).transform.rotation = (Quaternion)(((??)cameraRotation) ?? Quaternion.Euler(0f, 180f, 0f));
				component.fieldOfView = 0.5f;
				component.farClipPlane = 100000f;
				component.cullingMask = 8;
				Light component2 = new GameObject("LightIcon", new Type[1] { typeof(Light) }).GetComponent<Light>();
				((Component)component2).transform.position = new Vector3(10000f, 10000f, 10000f);
				((Component)component2).transform.rotation = Quaternion.Euler(5f, 180f, 5f);
				component2.type = (LightType)1;
				component2.cullingMask = 8;
				component2.intensity = lightIntensity;
				GameObject val = Object.Instantiate<GameObject>(prefab);
				Transform[] componentsInChildren = val.GetComponentsInChildren<Transform>();
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					((Component)componentsInChildren[i]).gameObject.layer = 3;
				}
				val.transform.position = Vector3.zero;
				val.transform.rotation = Quaternion.Euler(23f, 51f, 25.8f);
				((Object)val).name = ((Object)prefab).name;
				MeshRenderer[] componentsInChildren2 = val.GetComponentsInChildren<MeshRenderer>();
				Vector3 val2 = componentsInChildren2.Aggregate(Vector3.positiveInfinity, [<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (Vector3 cur, MeshRenderer renderer) =>
				{
					//IL_0000: Unknown result type (might be due to invalid IL or missing references)
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0007: Unknown result type (might be due to invalid IL or missing references)
					//IL_000a: Unknown result type (might be due to invalid IL or missing references)
					//IL_000f: Unknown result type (might be due to invalid IL or missing references)
					Bounds bounds2 = ((Renderer)renderer).bounds;
					return Vector3.Min(cur, ((Bounds)(ref bounds2)).min);
				});
				Vector3 val3 = componentsInChildren2.Aggregate(Vector3.negativeInfinity, [<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (Vector3 cur, MeshRenderer renderer) =>
				{
					//IL_0000: Unknown result type (might be due to invalid IL or missing references)
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0007: Unknown result type (might be due to invalid IL or missing references)
					//IL_000a: Unknown result type (might be due to invalid IL or missing references)
					//IL_000f: Unknown result type (might be due to invalid IL or missing references)
					Bounds bounds = ((Renderer)renderer).bounds;
					return Vector3.Max(cur, ((Bounds)(ref bounds)).max);
				});
				val.transform.position = new Vector3(10000f, 10000f, 10000f) - (val2 + val3) / 2f;
				Vector3 val4 = val3 - val2;
				val.AddComponent<TimedDestruction>().Trigger(1f);
				Rect val5 = default(Rect);
				((Rect)(ref val5))..ctor(0f, 0f, 128f, 128f);
				component.targetTexture = RenderTexture.GetTemporary((int)((Rect)(ref val5)).width, (int)((Rect)(ref val5)).height);
				component.fieldOfView = 20f;
				float num = (Mathf.Max(val4.x, val4.y) + 0.1f) / Mathf.Tan(component.fieldOfView * ((float)Math.PI / 180f)) * 1.1f;
				((Component)component).transform.position = new Vector3(10000f, 10000f, 10000f) + new Vector3(0f, 0f, num);
				component.Render();
				RenderTexture active = RenderTexture.active;
				RenderTexture.active = component.targetTexture;
				Texture2D val6 = new Texture2D((int)((Rect)(ref val5)).width, (int)((Rect)(ref val5)).height, (TextureFormat)4, false);
				val6.ReadPixels(new Rect(0f, 0f, (float)(int)((Rect)(ref val5)).width, (float)(int)((Rect)(ref val5)).height), 0, 0);
				val6.Apply();
				RenderTexture.active = active;
				prefab.GetComponent<Piece>().m_icon = Sprite.Create(val6, new Rect(0f, 0f, (float)(int)((Rect)(ref val5)).width, (float)(int)((Rect)(ref val5)).height), Vector2.one / 2f);
				((Component)component2).gameObject.SetActive(false);
				component.targetTexture.Release();
				((Component)component).gameObject.SetActive(false);
				val.SetActive(false);
				Object.DestroyImmediate((Object)(object)val);
				Object.Destroy((Object)(object)component);
				Object.Destroy((Object)(object)component2);
				Object.Destroy((Object)(object)((Component)component).gameObject);
				Object.Destroy((Object)(object)((Component)component2).gameObject);
			}
		}

		private static void DrawConfigTable(ConfigEntryBase cfg)
		{
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Expected O, but got Unknown
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Expected O, but got Unknown
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Expected O, but got Unknown
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Expected O, but got Unknown
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Expected O, but got Unknown
			bool valueOrDefault = cfg.Description.Tags.Select([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (object a) => (!(a.GetType().Name == "ConfigurationManagerAttributes")) ? null : ((bool?)a.GetType().GetField("ReadOnly")?.GetValue(a))).FirstOrDefault((bool? v) => v.HasValue).GetValueOrDefault();
			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(Array.Empty<GUILayoutOption>());
			foreach (Requirement req in new SerializedRequirements((string)cfg.BoxedValue).Reqs)
			{
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				int num2 = req.amount;
				if (int.TryParse(GUILayout.TextField(num2.ToString(), new GUIStyle(GUI.skin.textField)
				{
					fixedWidth = 40f
				}, Array.Empty<GUILayoutOption>()), 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
				}, Array.Empty<GUILayoutOption>());
				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
				}, Array.Empty<GUILayoutOption>()) != req.recover)
				{
					flag2 = !flag2;
					flag = true;
				}
				if (GUILayout.Button("x", new GUIStyle(GUI.skin.button)
				{
					fixedWidth = 21f
				}, Array.Empty<GUILayoutOption>()) && !valueOrDefault)
				{
					flag = true;
				}
				else
				{
					list.Add(new Requirement
					{
						amount = num2,
						itemName = text2,
						recover = flag2
					});
				}
				if (GUILayout.Button("+", new GUIStyle(GUI.skin.button)
				{
					fixedWidth = 21f
				}, Array.Empty<GUILayoutOption>()) && !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<[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)] T>(string group, string name, T value, ConfigDescription description)
		{
			ConfigEntry<T> val = plugin.Config.Bind<T>(group, name, value, description);
			configSync?.GetType().GetMethod("AddConfigEntry").MakeGenericMethod(typeof(T))
				.Invoke(configSync, new object[1] { val });
			return val;
		}

		private static ConfigEntry<T> config<[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)] T>(string group, string name, T value, string description)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			return config(group, name, value, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()));
		}
	}
	public static class GoExtensions
	{
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
		public static T GetOrAddComponent<[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)] T>(this GameObject gameObject) where T : Component
		{
			return gameObject.GetComponent<T>() ?? gameObject.AddComponent<T>();
		}
	}
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[PublicAPI]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	public 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));
				}
			}
		}
	}
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	public 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([<702532f4-32dc-46a6-8d9a-cabd38c9424b>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([<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)] string language = null)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			if (localizations.TryGetValue(language ?? PlayerPrefs.GetString("language", "English"), out var value))
			{
				return value;
			}
			value = new Localization();
			if (language != null)
			{
				value.SetupLanguage(language);
			}
			return value;
		}
	}
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	public class AdminSyncing
	{
		private static bool isServer;

		internal static bool registeredOnClient;

		[HarmonyPriority(700)]
		internal static void AdminStatusSync(ZNet __instance)
		{
			isServer = __instance.IsServer();
			if (BuildPiece._plugin != null)
			{
				if (isServer)
				{
					ZRoutedRpc.instance.Register<ZPackage>(BuildPiece._plugin.Info.Metadata.Name + " PMAdminStatusSync", (Action<long, ZPackage>)RPC_AdminPieceAddRemove);
				}
				else if (!registeredOnClient)
				{
					ZRoutedRpc.instance.Register<ZPackage>(BuildPiece._plugin.Info.Metadata.Name + " PMAdminStatusSync", (Action<long, ZPackage>)RPC_AdminPieceAddRemove);
					registeredOnClient = true;
				}
			}
			if (isServer)
			{
				((MonoBehaviour)ZNet.instance).StartCoroutine(WatchAdminListChanges());
			}
			static void SendAdmin(List<ZNetPeer> peers, bool isAdmin)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Expected O, but got Unknown
				ZPackage val = new ZPackage();
				val.Write(isAdmin);
				((MonoBehaviour)ZNet.instance).StartCoroutine(sendZPackage(peers, val));
			}
			static IEnumerator WatchAdminListChanges()
			{
				List<string> currentList = new List<string>(ZNet.instance.m_adminList.GetList());
				while (true)
				{
					yield return (object)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 (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				yield break;
			}
			byte[] array = package.GetArray();
			if (array != null && array.LongLength > 10000)
			{
				ZPackage val = new ZPackage();
				val.Write(4);
				MemoryStream memoryStream = new MemoryStream();
				using (DeflateStream deflateStream = new DeflateStream(memoryStream, CompressionLevel.Optimal))
				{
					deflateStream.Write(array, 0, array.Length);
				}
				val.Write(memoryStream.ToArray());
				package = val;
			}
			List<IEnumerator<bool>> writers = (from peer in peers
				where peer.IsReady()
				select peer into p
				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)
			{
				BaseUnityPlugin plugin = BuildPiece._plugin;
				string text = ((plugin != null) ? plugin.Info.Metadata.Name : null) + " PMAdminStatusSync";
				if (isServer)
				{
					peer.m_rpc.Invoke(text, new object[1] { pkg });
				}
				else
				{
					rpc.InvokeRoutedRPC(peer.m_server ? 0 : peer.m_uid, text, new object[1] { pkg });
				}
			}
			yield break;
		}

		internal static void RPC_AdminPieceAddRemove(long sender, ZPackage package)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Expected O, but got Unknown
			ZNetPeer peer = ZNet.instance.GetPeer(sender);
			bool flag = false;
			try
			{
				flag = package.ReadBool();
			}
			catch
			{
			}
			if (isServer)
			{
				ZRoutedRpc instance = ZRoutedRpc.instance;
				long everybody = ZRoutedRpc.Everybody;
				BaseUnityPlugin plugin = BuildPiece._plugin;
				instance.InvokeRoutedRPC(everybody, ((plugin != null) ? plugin.Info.Metadata.Name : null) + " PMAdminStatusSync", new object[1] { (object)new ZPackage() });
				if (ZNet.instance.ListContainsId(ZNet.instance.m_adminList, peer.m_rpc.GetSocket().GetHostName()))
				{
					ZPackage val = new ZPackage();
					val.Write(true);
					ZRpc rpc = peer.m_rpc;
					BaseUnityPlugin plugin2 = BuildPiece._plugin;
					rpc.Invoke(((plugin2 != null) ? plugin2.Info.Metadata.Name : null) + " PMAdminStatusSync", new object[1] { val });
				}
				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 (!Object.op_Implicit((Object)(object)ObjectDB.instance) || (Object)(object)ObjectDB.instance.GetItemPrefab("YmirRemains") == (Object)null)
				{
					continue;
				}
				Piece[] array = Object.FindObjectsOfType<Piece>();
				foreach (Piece val2 in array)
				{
					if (flag)
					{
						if (val2.m_name == name)
						{
							val2.m_enabled = true;
						}
					}
					else if (val2.m_name == name)
					{
						val2.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(((Object)component).name)))
					{
						pieces.Add(ZNetScene.instance.GetPrefab(((Object)component).name));
					}
				}
				else if (pieces.Contains(ZNetScene.instance.GetPrefab(((Object)component).name)))
				{
					pieces.Remove(ZNetScene.instance.GetPrefab(((Object)component).name));
				}
			}
		}
	}
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
	internal class RegisterClientRPCPatch
	{
		private static void Postfix(ZNet __instance, ZNetPeer peer)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			if (!__instance.IsServer())
			{
				ZRpc rpc = peer.m_rpc;
				BaseUnityPlugin plugin = BuildPiece._plugin;
				rpc.Register<ZPackage>(((plugin != null) ? plugin.Info.Metadata.Name : null) + " PMAdminStatusSync", (Action<ZRpc, ZPackage>)RPC_InitialAdminSync);
				return;
			}
			ZPackage val = new ZPackage();
			val.Write(__instance.ListContainsId(__instance.m_adminList, peer.m_rpc.GetSocket().GetHostName()));
			ZRpc rpc2 = peer.m_rpc;
			BaseUnityPlugin plugin2 = BuildPiece._plugin;
			rpc2.Invoke(((plugin2 != null) ? plugin2.Info.Metadata.Name : null) + " PMAdminStatusSync", new object[1] { val });
		}

		private static void RPC_InitialAdminSync(ZRpc rpc, ZPackage package)
		{
			AdminSyncing.RPC_AdminPieceAddRemove(0L, package);
		}
	}
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	public static class PiecePrefabManager
	{
		[<5ea91132-7291-4072-bba1-fdb04647c6e6>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, PieceCategory> PieceCategories;

		private static readonly Dictionary<string, PieceCategory> OtherPieceCategories;

		private static readonly Dictionary<PieceCategory, string> VanillaLabels;

		internal static bool CategoryRefreshNeeded;

		static PiecePrefabManager()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Expected O, but got Unknown
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Expected O, but got Unknown
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Expected O, but got Unknown
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Expected O, but got Unknown
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Expected O, but got Unknown
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Expected O, but got Unknown
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Expected O, but got Unknown
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Expected O, but got Unknown
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Expected O, but got Unknown
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e9: Expected O, but got Unknown
			//IL_02e9: Expected O, but got Unknown
			//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0318: Unknown result type (might be due to invalid IL or missing references)
			//IL_0325: Expected O, but got Unknown
			//IL_0326: Unknown result type (might be due to invalid IL or missing references)
			//IL_0354: Unknown result type (might be due to invalid IL or missing references)
			//IL_0361: Expected O, but got Unknown
			//IL_0362: Unknown result type (might be due to invalid IL or missing references)
			//IL_038f: Unknown result type (might be due to invalid IL or missing references)
			//IL_039d: Expected O, but got Unknown
			//IL_039e: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d9: Expected O, but got Unknown
			//IL_03da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0408: Unknown result type (might be due to invalid IL or missing references)
			//IL_0415: Expected O, but got Unknown
			//IL_0443: Unknown result type (might be due to invalid IL or missing references)
			//IL_0450: Expected O, but got Unknown
			bundleCache = new Dictionary<BundleId, AssetBundle>();
			piecePrefabs = new List<GameObject>();
			PieceCategories = new Dictionary<string, PieceCategory>();
			OtherPieceCategories = new Dictionary<string, PieceCategory>();
			VanillaLabels = new Dictionary<PieceCategory, string>();
			Harmony val = new Harmony("org.bepinex.helpers.PieceManager");
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(FejdStartup), "Awake", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(BuildPiece), "Patch_FejdStartup", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Localization), "LoadCSV", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(LocalizeKey), "AddLocalizedKeys", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Localization), "SetupLanguage", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(LocalizationCache), "LocalizationPostfix", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ObjectDB), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "Patch_ObjectDBInit", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ObjectDB), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(BuildPiece), "Patch_ObjectDBInit", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ObjectDB), "CopyOtherDB", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "Patch_ObjectDBInit", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ZNet), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(AdminSyncing), "AdminStatusSync", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ZNetScene), "Awake", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "Patch_ZNetSceneAwake", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ZNetScene), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "RefFixPatch_ZNetSceneAwake", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(PieceTable), "UpdateAvailable", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "UpdateAvailable_Transpiler", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(PieceTable), "UpdateAvailable", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "UpdateAvailable_Prefix", (Type[])null, (Type[])null)), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "UpdateAvailable_Postfix", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Player), "SetPlaceMode", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "Patch_SetPlaceMode", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Hud), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "Hud_AwakeCreateTabs", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Hud), "UpdateBuild", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "RepositionCatsIfNeeded", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Hud), "LateUpdate", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "RepositionCatsIfNeeded", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Enum), "GetValues", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "EnumGetValuesPatch", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Enum), "GetNames", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "EnumGetNamesPatch", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		public static AssetBundle RegisterAssetBundle(string assetBundleFileName, string folderName = "assets")
		{
			BundleId bundleId = default(BundleId);
			bundleId.assetBundleFileName = assetBundleFileName;
			bundleId.folderName = folderName;
			BundleId key = bundleId;
			if (!bundleCache.TryGetValue(key, out var value))
			{
				Dictionary<BundleId, AssetBundle> dictionary = bundleCache;
				AssetBundle? obj = ((IEnumerable<AssetBundle>)Resources.FindObjectsOfTypeAll<AssetBundle>()).FirstOrDefault((Func<AssetBundle, bool>)([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (AssetBundle a) => ((Object)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 ((Object)(object)assets == (Object)null)
			{
				Debug.LogError((object)"Failed to load asset bundle. Please make sure to mark all asset bundles as embedded resources.");
				return null;
			}
			GameObject val = assets.LoadAsset<GameObject>(prefabName);
			if ((Object)(object)val == (Object)null)
			{
				Debug.LogError((object)("Failed to load prefab " + prefabName + " from asset bundle " + ((Object)assets).name));
				return null;
			}
			piecePrefabs.Add(val);
			return val;
		}

		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(PieceCategory)) && PieceCategories.Count != 0)
			{
				PieceCategory[] array = (PieceCategory[])(object)new 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(PieceCategory)) && PieceCategories.Count != 0)
			{
				__result = CollectionExtensions.AddRangeToArray<string>(__result, PieceCategories.Keys.ToArray());
			}
		}

		public static Dictionary<PieceCategory, string> GetPieceCategoriesMap()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			Array values = Enum.GetValues(typeof(PieceCategory));
			string[] names = Enum.GetNames(typeof(PieceCategory));
			Dictionary<PieceCategory, string> dictionary = new Dictionary<PieceCategory, string>();
			for (int i = 0; i < values.Length; i++)
			{
				dictionary[(PieceCategory)values.GetValue(i)] = names[i];
			}
			return dictionary;
		}

		public static PieceCategory GetCategory(string name)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			if (Enum.TryParse<PieceCategory>(name, ignoreCase: true, out PieceCategory result))
			{
				return result;
			}
			if (PieceCategories.TryGetValue(name, out result))
			{
				return result;
			}
			if (OtherPieceCategories.TryGetValue(name, out result))
			{
				return result;
			}
			Dictionary<PieceCategory, string> pieceCategoriesMap = GetPieceCategoriesMap();
			foreach (KeyValuePair<PieceCategory, string> item in pieceCategoriesMap)
			{
				if (item.Value == name)
				{
					result = item.Key;
					OtherPieceCategories[name] = result;
					return result;
				}
			}
			result = (PieceCategory)(pieceCategoriesMap.Count - 1);
			PieceCategories[name] = result;
			string categoryToken = GetCategoryToken(name);
			Localization.instance.AddWord(categoryToken, name);
			return result;
		}

		internal static void CreateCategoryTabs()
		{
			if (Object.op_Implicit((Object)(object)Hud.instance))
			{
				int num = ModifiedMaxCategory();
				for (int i = Hud.instance.m_pieceCategoryTabs.Length; i < num; i++)
				{
					GameObject val = CreateCategoryTab();
					Hud.instance.m_pieceCategoryTabs = CollectionExtensions.AddItem<GameObject>((IEnumerable<GameObject>)Hud.instance.m_pieceCategoryTabs, val).ToArray();
				}
				if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && Object.op_Implicit((Object)(object)Player.m_localPlayer.m_buildPieces))
				{
					RepositionCategories(Player.m_localPlayer.m_buildPieces);
					Player.m_localPlayer.UpdateAvailablePiecesList();
				}
			}
		}

		private static GameObject CreateCategoryTab()
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Hud.instance.m_pieceCategoryTabs[0];
			GameObject val2 = Object.Instantiate<GameObject>(Hud.instance.m_pieceCategoryTabs[0], val.transform.parent);
			val2.SetActive(false);
			UIInputHandler orAddComponent = val2.GetOrAddComponent<UIInputHandler>();
			orAddComponent.m_onLeftDown = (Action<UIInputHandler>)Delegate.Combine(orAddComponent.m_onLeftDown, new Action<UIInputHandler>(Hud.instance.OnLeftClickCategory));
			TMP_Text[] componentsInChildren = val2.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)1;
				obj.overflowMode = (TextOverflowModes)3;
			}
			return val2;
		}

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

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

		private static List<CodeInstruction> TranspileMaxCategory(IEnumerable<CodeInstruction> instructions, int maxOffset)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			int num = GetMaxCategoryOrDefault() + maxOffset;
			List<CodeInstruction> list = new List<CodeInstruction>();
			foreach (CodeInstruction instruction in instructions)
			{
				if (CodeInstructionExtensions.LoadsConstant(instruction, (long)num))
				{
					list.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "ModifiedMaxCategory", (Type[])null, (Type[])null)));
					if (maxOffset != 0)
					{
						list.Add(new CodeInstruction(OpCodes.Ldc_I4, (object)maxOffset));
						list.Add(new CodeInstruction(OpCodes.Add, (object)null));
					}
				}
				else
				{
					list.Add(instruction);
				}
			}
			return list;
		}

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

		private static HashSet<PieceCategory> CategoriesInPieceTable(PieceTable pieceTable)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			HashSet<PieceCategory> hashSet = new HashSet<PieceCategory>();
			Piece val = default(Piece);
			foreach (GameObject item in pieceTable.m_pieces.Where([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (GameObject pieceFab) => (Object)(object)pieceFab != (Object)null))
			{
				if (item.TryGetComponent<Piece>(ref val))
				{
					hashSet.Add(val.m_category);
				}
			}
			return hashSet;
		}

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

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

		private static void RepositionCategories(PieceTable pieceTable)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Expected O, but got Unknown
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = (RectTransform)Hud.instance.m_pieceCategoryTabs[0].transform;
			RectTransform val2 = (RectTransform)Hud.instance.m_pieceCategoryRoot.transform;
			RectTransform val3 = (RectTransform)Hud.instance.m_pieceSelectionWindow.transform;
			HorizontalLayoutGroup val4 = default(HorizontalLayoutGroup);
			if (((Component)((Transform)val).parent).TryGetComponent<HorizontalLayoutGroup>(ref val4))
			{
				Object.DestroyImmediate((Object)(object)val4);
			}
			Rect rect = val.rect;
			Vector2 size = ((Rect)(ref rect)).size;
			GridLayoutGroup val5 = default(GridLayoutGroup);
			GridLayoutGroup obj = (((Component)((Transform)val).parent).TryGetComponent<GridLayoutGroup>(ref val5) ? val5 : ((Component)((Transform)val).parent).gameObject.AddComponent<GridLayoutGroup>());
			obj.cellSize = size;
			obj.spacing = new Vector2(0f, 1f);
			obj.constraint = (Constraint)1;
			obj.constraintCount = 5;
			((LayoutGroup)obj).childAlignment = (TextAnchor)4;
			HashSet<PieceCategory> hashSet = CategoriesInPieceTable(pieceTable);
			UpdatePieceTableCategories(pieceTable, hashSet);
			rect = val2.rect;
			int num = Mathf.Max((int)(((Rect)(ref rect)).width / size.x), 1);
			int count = pieceTable.m_categories.Count;
			float num2 = (0f - size.x) * (float)num / 2f + size.x / 2f;
			float num3 = (size.y + 1f) * Mathf.Floor((float)(count - 1) / (float)num) + 5f;
			new Vector2(num2, num3);
			int num4 = Mathf.CeilToInt((float)count / (float)num);
			float num5 = (size.y + 1f) * (float)num4;
			RectTransform component = ((Component)((Transform)val).parent).GetComponent<RectTransform>();
			component.anchoredPosition = new Vector2(component.anchoredPosition.x, num5 / 2f);
			int num6 = 0;
			for (int i = 0; i < Hud.instance.m_pieceCategoryTabs.Length; i++)
			{
				GameObject val6 = Hud.instance.m_pieceCategoryTabs[i];
				if ((Object)(object)val6 == (Object)null)
				{
					continue;
				}
				if (i >= pieceTable.m_categories.Count)
				{
					val6.SetActive(false);
					continue;
				}
				PieceCategory item = pieceTable.m_categories[i];
				string text = pieceTable.m_categoryLabels[i];
				if (hashSet.Contains(item))
				{
					num6++;
				}
				val6.GetComponentInChildren<TMP_Text>().text = Localization.instance.Localize(text);
			}
			Transform obj2 = ((Transform)val3).Find("Bkg2");
			RectTransform val7 = (RectTransform)((obj2 != null) ? ((Component)obj2).transform : null);
			if (Object.op_Implicit((Object)(object)val7))
			{
				float num7 = (size.y + 1f) * (float)Mathf.Max(0, Mathf.FloorToInt((float)(num6 - 1) / (float)num));
				val7.offsetMax = new Vector2(val7.offsetMax.x, num7);
			}
			else
			{
				Debug.LogWarning((object)"RefreshCategories: Could not find background image");
			}
			((Component)Hud.instance).GetComponentInParent<Localize>().RefreshLocalization();
		}

		private static void UpdatePieceTableCategories(PieceTable pieceTable, HashSet<PieceCategory> visibleCategories)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < GetMaxCategoryOrDefault(); i++)
			{
				PieceCategory val = (PieceCategory)i;
				if (visibleCategories.Contains(val) && !pieceTable.m_categories.Contains(val))
				{
					pieceTable.m_categories.Add(val);
					pieceTable.m_categoryLabels.Add(GetVanillaLabel(val));
				}
				if (!visibleCategories.Contains(val) && pieceTable.m_categories.Contains(val))
				{
					int index = pieceTable.m_categories.IndexOf(val);
					pieceTable.m_categories.RemoveAt(index);
					pieceTable.m_categoryLabels.RemoveAt(index);
				}
			}
			foreach (KeyValuePair<string, PieceCategory> pieceCategory in PieceCategories)
			{
				string key = pieceCategory.Key;
				PieceCategory value = pieceCategory.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(PieceCategory category)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (!VanillaLabels.ContainsKey(category))
			{
				SearchVanillaLabels();
			}
			if (!VanillaLabels.TryGetValue(category, out var value))
			{
				return string.Empty;
			}
			return value;
		}

		private static void SearchVanillaLabels()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			PieceTable[] array = Resources.FindObjectsOfTypeAll<PieceTable>();
			foreach (PieceTable val in array)
			{
				for (int j = 0; j < val.m_categories.Count; j++)
				{
					PieceCategory key = val.m_categories[j];
					if (j < val.m_categoryLabels.Count && !VanillaLabels.ContainsKey(key) && !string.IsNullOrEmpty(val.m_categoryLabels[j]))
					{
						VanillaLabels[key] = val.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 (Object.op_Implicit((Object)(object)__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)
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			foreach (GameObject piecePrefab in piecePrefabs)
			{
				if (__instance.m_prefabs.Contains(piecePrefab) && Object.op_Implicit((Object)(object)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 text in activeTools)
				{
					GameObject itemPrefab = __instance.GetItemPrefab(text);
					PieceTable val = ((itemPrefab != null) ? itemPrefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_buildPieces : null);
					if (val != null && !val.m_pieces.Contains(registeredPiece.Prefab))
					{
						val.m_pieces.Add(registeredPiece.Prefab);
					}
				}
			}
		}
	}
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	[PublicAPI]
	public class Conversion
	{
		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
		internal class ConversionConfig
		{
			public ConfigEntry<string> input;

			public ConfigEntry<string> output;
		}

		public string Input;

		public string Output;

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)]
		internal ConversionConfig config;

		public Conversion(BuildPiece conversionPiece)
		{
			conversionPiece.Conversions.Add(this);
		}
	}
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	[PublicAPI]
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	public class SnapPointMaker
	{
		private static List<GameObject> _objectsToApplySnaps;

		static SnapPointMaker()
		{
			_objectsToApplySnaps = new List<GameObject>();
		}

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

		public static void ApplySnapPoints()
		{
			foreach (GameObject objectsToApplySnap in _objectsToApplySnaps)
			{
				GrabVerticesAssignSnaps(objectsToApplySnap);
			}
		}

		private static void GrabVerticesAssignSnaps(GameObject obj)
		{
			Vector3[] colliderVertexPosRotated = GetColliderVertexPosRotated(obj);
			AttachSnapPoints(obj, colliderVertexPosRotated);
		}

		private static Vector3[] GetColliderVertexPosRotated(GameObject obj)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			Vector3[] array = (Vector3[])(object)new Vector3[8];
			BoxCollider componentInChildren = obj.GetComponentInChildren<BoxCollider>();
			if ((Object)(object)componentInChildren == (Object)null)
			{
				return array;
			}
			Transform transform = obj.transform;
			Vector3 val = componentInChildren.center - componentInChildren.size * 0.5f;
			Vector3 val2 = componentInChildren.center + componentInChildren.size * 0.5f;
			array[0] = transform.TransformPoint(new Vector3(val.x, val.y, val.z));
			array[1] = transform.TransformPoint(new Vector3(val.x, val.y, val2.z));
			array[2] = transform.TransformPoint(new Vector3(val.x, val2.y, val.z));
			array[3] = transform.TransformPoint(new Vector3(val.x, val2.y, val2.z));
			array[4] = transform.TransformPoint(new Vector3(val2.x, val.y, val.z));
			array[5] = transform.TransformPoint(new Vector3(val2.x, val.y, val2.z));
			array[6] = transform.TransformPoint(new Vector3(val2.x, val2.y, val.z));
			array[7] = transform.TransformPoint(new Vector3(val2.x, val2.y, val2.z));
			return array;
		}

		private static void AttachSnapPoints(GameObject objecttosnap, Vector3[] vector3S)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			foreach (Vector3 val in vector3S)
			{
				Object.Instantiate<GameObject>(new GameObject
				{
					name = "_snappoint",
					tag = "snappoint",
					layer = 10
				}, val, Quaternion.identity, objecttosnap.transform).SetActive(false);
			}
		}
	}
}
namespace LocalizationManager
{
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[PublicAPI]
	public class Localizer
	{
		private static readonly Dictionary<string, Dictionary<string, Func<string>>> PlaceholderProcessors;

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

		private static readonly ConditionalWeakTable<Localization, string> localizationLanguage;

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

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)]
		private static BaseUnityPlugin _plugin;

		private static readonly List<string> fileExtensions;

		private static BaseUnityPlugin plugin
		{
			get
			{
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: Expected O, but got Unknown
				if (_plugin == null)
				{
					IEnumerable<TypeInfo> source;
					try
					{
						source = Assembly.GetExecutingAssembly().DefinedTypes.ToList();
					}
					catch (ReflectionTypeLoadException ex)
					{
						source = from t in ex.Types
							where t != null
							select t.GetTypeInfo();
					}
					_plugin = (BaseUnityPlugin)Chainloader.ManagerObject.GetComponent((Type)source.First([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (TypeInfo t) => t.IsClass && typeof(BaseUnityPlugin).IsAssignableFrom(t)));
				}
				return _plugin;
			}
		}

		private static void UpdatePlaceholderText(Localization localization, string key)
		{
			localizationLanguage.TryGetValue(localization, out var value);
			string text = loadedTexts[value][key];
			if (PlaceholderProcessors.TryGetValue(key, out var value2))
			{
				text = value2.Aggregate(text, [<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (string current, KeyValuePair<string, Func<string>> kv) => current.Replace("{" + kv.Key + "}", kv.Value()));
			}
			localization.AddWord(key, text);
		}

		public static void AddPlaceholder<T>(string key, string placeholder, ConfigEntry<T> config, [<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(new byte[] { 2, 1, 1 })] Func<T, string> convertConfigValue = null)
		{
			if (convertConfigValue == null)
			{
				convertConfigValue = (T val) => val.ToString();
			}
			if (!PlaceholderProcessors.ContainsKey(key))
			{
				PlaceholderProcessors[key] = new Dictionary<string, Func<string>>();
			}
			config.SettingChanged += [<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (object _, EventArgs _) =>
			{
				UpdatePlaceholder();
			};
			if (loadedTexts.ContainsKey(Localization.instance.GetSelectedLanguage()))
			{
				UpdatePlaceholder();
			}
			void UpdatePlaceholder()
			{
				PlaceholderProcessors[key][placeholder] = () => convertConfigValue(config.Value);
				UpdatePlaceholderText(Localization.instance, key);
			}
		}

		public static void AddText(string key, string text)
		{
			List<WeakReference<Localization>> list = new List<WeakReference<Localization>>();
			foreach (WeakReference<Localization> localizationObject in localizationObjects)
			{
				if (localizationObject.TryGetTarget(out var target))
				{
					Dictionary<string, string> dictionary = loadedTexts[localizationLanguage.GetOrCreateValue(target)];
					if (!target.m_translations.ContainsKey(key))
					{
						dictionary[key] = text;
						target.AddWord(key, text);
					}
				}
				else
				{
					list.Add(localizationObject);
				}
			}
			foreach (WeakReference<Localization> item in list)
			{
				localizationObjects.Remove(item);
			}
		}

		public static void Load()
		{
			LoadLocalization(Localization.instance, Localization.instance.GetSelectedLanguage());
		}

		private static void LoadLocalization(Localization __instance, string language)
		{
			if (!localizationLanguage.Remove(__instance))
			{
				localizationObjects.Add(new WeakReference<Localization>(__instance));
			}
			localizationLanguage.Add(__instance, language);
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			foreach (string item in from f in Directory.GetFiles(Path.GetDirectoryName(Paths.PluginPath), plugin.Info.Metadata.Name + ".*", SearchOption.AllDirectories)
				where fileExtensions.IndexOf(Path.GetExtension(f)) >= 0
				select f)
			{
				string text = Path.GetFileNameWithoutExtension(item).Split(new char[1] { '.' })[1];
				if (dictionary.ContainsKey(text))
				{
					Debug.LogWarning((object)("Duplicate key " + text + " found for " + plugin.Info.Metadata.Name + ". The duplicate file found at " + item + " will be skipped."));
				}
				else
				{
					dictionary[text] = item;
				}
			}
			byte[] array = LoadTranslationFromAssembly("English");
			if (array == null)
			{
				throw new Exception("Found no English localizations in mod " + plugin.Info.Metadata.Name + ". Expected an embedded resource translations/English.json or translations/English.yml.");
			}
			Dictionary<string, string> dictionary2 = new DeserializerBuilder().IgnoreFields().Build().Deserialize<Dictionary<string, string>>(Encoding.UTF8.GetString(array));
			if (dictionary2 == null)
			{
				throw new Exception("Localization for mod " + plugin.Info.Metadata.Name + " failed: Localization file was empty.");
			}
			string text2 = null;
			if (language != "English")
			{
				if (dictionary.ContainsKey(language))
				{
					text2 = File.ReadAllText(dictionary[language]);
				}
				else
				{
					byte[] array2 = LoadTranslationFromAssembly(language);
					if (array2 != null)
					{
						text2 = Encoding.UTF8.GetString(array2);
					}
				}
			}
			if (text2 == null && dictionary.ContainsKey("English"))
			{
				text2 = File.ReadAllText(dictionary["English"]);
			}
			if (text2 != null)
			{
				foreach (KeyValuePair<string, string> item2 in new DeserializerBuilder().IgnoreFields().Build().Deserialize<Dictionary<string, string>>(text2) ?? new Dictionary<string, string>())
				{
					dictionary2[item2.Key] = item2.Value;
				}
			}
			loadedTexts[language] = dictionary2;
			foreach (KeyValuePair<string, string> item3 in dictionary2)
			{
				UpdatePlaceholderText(__instance, item3.Key);
			}
		}

		static Localizer()
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			PlaceholderProcessors = new Dictionary<string, Dictionary<string, Func<string>>>();
			loadedTexts = new Dictionary<string, Dictionary<string, string>>();
			localizationLanguage = new ConditionalWeakTable<Localization, string>();
			localizationObjects = new List<WeakReference<Localization>>();
			fileExtensions = new List<string> { ".json", ".yml" };
			new Harmony("org.bepinex.helpers.LocalizationManager").Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Localization), "LoadCSV", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Localizer), "LoadLocalization", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		[return: <5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)]
		private static byte[] LoadTranslationFromAssembly(string language)
		{
			foreach (string fileExtension in fileExtensions)
			{
				byte[] array = ReadEmbeddedFileBytes("translations." + language + fileExtension);
				if (array != null)
				{
					return array;
				}
			}
			return null;
		}

		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(2)]
		public static byte[] ReadEmbeddedFileBytes([<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(1)] string resourceFileName, Assembly containingAssembly = null)
		{
			using MemoryStream memoryStream = new MemoryStream();
			if ((object)containingAssembly == null)
			{
				containingAssembly = Assembly.GetCallingAssembly();
			}
			string text = containingAssembly.GetManifestResourceNames().FirstOrDefault([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (string str) => str.EndsWith(resourceFileName, StringComparison.Ordinal));
			if (text != null)
			{
				containingAssembly.GetManifestResourceStream(text)?.CopyTo(memoryStream);
			}
			return (memoryStream.Length == 0L) ? null : memoryStream.ToArray();
		}
	}
}
namespace ItemManager
{
	[PublicAPI]
	public enum CraftingTable
	{
		Disabled,
		Inventory,
		[InternalName("piece_workbench")]
		Workbench,
		[InternalName("piece_cauldron")]
		Cauldron,
		[InternalName("piece_MeadCauldron")]
		MeadCauldron,
		[InternalName("forge")]
		Forge,
		[InternalName("piece_artisanstation")]
		ArtisanTable,
		[InternalName("piece_stonecutter")]
		StoneCutter,
		[InternalName("piece_magetable")]
		MageTable,
		[InternalName("piece_preptable")]
		PrepTable,
		[InternalName("blackforge")]
		BlackForge,
		Custom
	}
	[PublicAPI]
	public enum ConversionPiece
	{
		Disabled,
		[InternalName("smelter")]
		Smelter,
		[InternalName("charcoal_kiln")]
		CharcoalKiln,
		[InternalName("blastfurnace")]
		BlastFurnace,
		[InternalName("windmill")]
		Windmill,
		[InternalName("piece_spinningwheel")]
		SpinningWheel,
		[InternalName("eitrrefinery")]
		EitrRefinery,
		Custom
	}
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	public class InternalName : Attribute
	{
		public readonly string internalName;

		public InternalName(string internalName)
		{
			this.internalName = internalName;
		}
	}
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	[PublicAPI]
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	public class RequiredResourceList
	{
		public readonly List<Requirement> Requirements = new List<Requirement>();

		public bool Free;

		public void Add(string itemName, int amount, int quality = 0)
		{
			Requirements.Add(new Requirement
			{
				itemName = itemName,
				amount = amount,
				quality = quality
			});
		}

		public void Add(string itemName, ConfigEntry<int> amountConfig, int quality = 0)
		{
			Requirements.Add(new Requirement
			{
				itemName = itemName,
				amountConfig = amountConfig,
				quality = quality
			});
		}
	}
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	[PublicAPI]
	public class CraftingStationList
	{
		public readonly List<CraftingStationConfig> Stations = new List<CraftingStationConfig>();

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

		public void Add(string customTable, int level)
		{
			Stations.Add(new CraftingStationConfig
			{
				Table = CraftingTable.Custom,
				level = level,
				custom = customTable
			});
		}
	}
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	[PublicAPI]
	public class ItemRecipe
	{
		public readonly RequiredResourceList RequiredItems = new RequiredResourceList();

		public readonly RequiredResourceList RequiredUpgradeItems = new RequiredResourceList();

		public readonly CraftingStationList Crafting = new CraftingStationList();

		public int CraftAmount = 1;

		public bool RequireOnlyOneIngredient;

		public float QualityResultAmountMultiplier = 1f;

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)]
		public ConfigEntryBase RecipeIsActive;
	}
	[PublicAPI]
	public class Trade
	{
		public Trader Trader;

		public uint Price;

		public uint Stack = 1u;

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)]
		public string RequiredGlobalKey;
	}
	[Flags]
	[PublicAPI]
	public enum Trader
	{
		None = 0,
		Haldor = 1,
		Hildir = 2
	}
	public struct Requirement
	{
		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(1)]
		public string itemName;

		public int amount;

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)]
		public ConfigEntry<int> amountConfig;

		[Description("Set to a non-zero value to apply the requirement only for a specific quality")]
		public int quality;
	}
	public struct CraftingStationConfig
	{
		public CraftingTable Table;

		public int level;

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)]
		public string custom;
	}
	[Flags]
	public enum Configurability
	{
		Disabled = 0,
		Recipe = 1,
		Stats = 2,
		Drop = 4,
		Trader = 8,
		Full = 0xF
	}
	[PublicAPI]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	public class DropTargets
	{
		public readonly List<DropTarget> Drops = new List<DropTarget>();

		public void Add(string creatureName, float chance, int min = 1, int? max = null, bool levelMultiplier = true)
		{
			Drops.Add(new DropTarget
			{
				creature = creatureName,
				chance = chance,
				min = min,
				max = max.GetValueOrDefault(min),
				levelMultiplier = levelMultiplier
			});
		}
	}
	public struct DropTarget
	{
		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(1)]
		public string creature;

		public int min;

		public int max;

		public float chance;

		public bool levelMultiplier;
	}
	public enum Toggle
	{
		On = 1,
		Off = 0
	}
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[PublicAPI]
	public class Item
	{
		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
		private class ItemConfig
		{
			[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(new byte[] { 2, 1 })]
			public ConfigEntry<string> craft;

			[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(new byte[] { 2, 1 })]
			public ConfigEntry<string> upgrade;

			public ConfigEntry<CraftingTable> table;

			public ConfigEntry<int> tableLevel;

			public ConfigEntry<string> customTable;

			[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)]
			public ConfigEntry<int> maximumTableLevel;

			public ConfigEntry<Toggle> requireOneIngredient;

			public ConfigEntry<float> qualityResultAmountMultiplier;
		}

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
		private class TraderConfig
		{
			public ConfigEntry<Trader> trader;

			public ConfigEntry<uint> price;

			public ConfigEntry<uint> stack;

			public ConfigEntry<string> requiredGlobalKey;
		}

		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		private class RequirementQuality
		{
			public int quality;
		}

		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(2)]
		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
		private class ConfigurationManagerAttributes
		{
			[UsedImplicitly]
			public int? Order;

			[UsedImplicitly]
			public bool? Browsable;

			[UsedImplicitly]
			public string Category;

			[UsedImplicitly]
			[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(new byte[] { 2, 1 })]
			public Action<ConfigEntryBase> CustomDrawer;

			public Func<bool> browsability;
		}

		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		[PublicAPI]
		public enum DamageModifier
		{
			Normal,
			Resistant,
			Weak,
			Immune,
			Ignore,
			VeryResistant,
			VeryWeak,
			None
		}

		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		private delegate void setDmgFunc(ref DamageTypes dmg, float value);

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
		private class SerializedRequirements
		{
			public readonly List<Requirement> Reqs;

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

			public SerializedRequirements(string reqs)
				: this(reqs.Split(new char[1] { ',' }).Select([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (string r) =>
				{
					string[] array = r.Split(new char[1] { ':' });
					Requirement result = default(Requirement);
					result.itemName = array[0];
					result.amount = ((array.Length <= 1 || !int.TryParse(array[1], out var result2)) ? 1 : result2);
					result.quality = ((array.Length > 2 && int.TryParse(array[2], out var result3)) ? result3 : 0);
					return result;
				}).ToList())
			{
			}

			public override string ToString()
			{
				return string.Join(",", Reqs.Select([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (Requirement r) => $"{r.itemName}:{r.amount}" + ((r.quality > 0) ? $":{r.quality}" : "")));
			}

			[return: <5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)]
			public static ItemDrop fetchByName(ObjectDB objectDB, string name)
			{
				GameObject itemPrefab = objectDB.GetItemPrefab(name);
				ItemDrop obj = ((itemPrefab != null) ? itemPrefab.GetComponent<ItemDrop>() : null);
				if ((Object)(object)obj == (Object)null)
				{
					Debug.LogWarning((object)("The required item '" + name + "' does not exist."));
				}
				return obj;
			}

			public static Requirement[] toPieceReqs(ObjectDB objectDB, SerializedRequirements craft, SerializedRequirements upgrade)
			{
				//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_0178: Unknown result type (might be due to invalid IL or missing references)
				//IL_017d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0185: Unknown result type (might be due to invalid IL or missing references)
				//IL_018c: Unknown result type (might be due to invalid IL or missing references)
				//IL_018f: Expected O, but got Unknown
				//IL_0194: Expected O, but got Unknown
				//IL_011c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0125: Expected O, but got Unknown
				Dictionary<string, Requirement> dictionary = craft.Reqs.Where((Requirement r) => r.itemName != "").ToDictionary((Func<Requirement, string>)([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (Requirement r) => r.itemName), (Func<Requirement, Requirement>)([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (Requirement r) =>
				{
					//IL_000d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0012: Unknown result type (might be due to invalid IL or missing references)
					//IL_002f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0036: Unknown result type (might be due to invalid IL or missing references)
					//IL_003e: Expected O, but got Unknown
					ItemDrop val6 = ResItem(r);
					return (val6 != null) ? new Requirement
					{
						m_amount = (r.amountConfig?.Value ?? r.amount),
						m_resItem = val6,
						m_amountPerLevel = 0
					} : ((Requirement)null);
				}));
				List<Requirement> list = dictionary.Values.Where([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (Requirement v) => v != null).ToList();
				foreach (Requirement item in upgrade.Reqs.Where((Requirement r) => r.itemName != ""))
				{
					if (item.quality > 0)
					{
						ItemDrop val = ResItem(item);
						if (val != null)
						{
							Requirement val2 = new Requirement
							{
								m_resItem = val,
								m_amountPerLevel = (item.amountConfig?.Value ?? item.amount),
								m_amount = 0
							};
							list.Add(val2);
							requirementQuality.Add(val2, new RequirementQuality
							{
								quality = item.quality
							});
						}
						continue;
					}
					if (!dictionary.TryGetValue(item.itemName, out var value) || value == null)
					{
						ItemDrop val3 = ResItem(item);
						if (val3 != null)
						{
							string itemName = item.itemName;
							Requirement val4 = new Requirement
							{
								m_resItem = val3,
								m_amount = 0
							};
							Requirement val5 = val4;
							dictionary[itemName] = val4;
							value = val5;
							list.Add(value);
						}
					}
					if (value != null)
					{
						value.m_amountPerLevel = item.amountConfig?.Value ?? item.amount;
					}
				}
				return list.ToArray();
				[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(2)]
				ItemDrop ResItem(Requirement r)
				{
					return fetchByName(objectDB, r.itemName);
				}
			}
		}

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
		private class SerializedDrop
		{
			public readonly List<DropTarget> Drops;

			public SerializedDrop(List<DropTarget> drops)
			{
				Drops = drops;
			}

			public SerializedDrop(string drops)
			{
				Drops = ((drops == "") ? ((IEnumerable<string>)Array.Empty<string>()) : ((IEnumerable<string>)drops.Split(new char[1] { ',' }))).Select([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (string r) =>
				{
					string[] array = r.Split(new char[1] { ':' });
					if (array.Length <= 2 || !int.TryParse(array[2], out var result))
					{
						result = 1;
					}
					if (array.Length <= 3 || !int.TryParse(array[3], out var result2))
					{
						result2 = result;
					}
					bool levelMultiplier = array.Length <= 4 || array[4] != "0";
					DropTarget result3 = default(DropTarget);
					result3.creature = array[0];
					result3.chance = ((array.Length > 1 && float.TryParse(array[1], NumberStyles.Float, CultureInfo.InvariantCulture, out var result4)) ? result4 : 1f);
					result3.min = result;
					result3.max = result2;
					result3.levelMultiplier = levelMultiplier;
					return result3;
				}).ToList();
			}

			public override string ToString()
			{
				return string.Join(",", Drops.Select([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (DropTarget r) => $"{r.creature}:{r.chance.ToString(CultureInfo.InvariantCulture)}:{r.min}:" + ((r.min == r.max) ? "" : $"{r.max}") + (r.levelMultiplier ? "" : ":0")));
			}

			[return: <5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)]
			private static Character fetchByName(ZNetScene netScene, string name)
			{
				GameObject prefab = netScene.GetPrefab(name);
				Character obj = ((prefab != null) ? prefab.GetComponent<Character>() : null);
				if ((Object)(object)obj == (Object)null)
				{
					Debug.LogWarning((object)("The drop target character '" + name + "' does not exist."));
				}
				return obj;
			}

			public Dictionary<Character, Drop> toCharacterDrops(ZNetScene netScene, GameObject item)
			{
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Expected O, but got Unknown
				Dictionary<Character, Drop> dictionary = new Dictionary<Character, Drop>();
				foreach (DropTarget drop in Drops)
				{
					Character val = fetchByName(netScene, drop.creature);
					if (val != null)
					{
						dictionary[val] = new Drop
						{
							m_prefab = item,
							m_amountMin = drop.min,
							m_amountMax = drop.max,
							m_chance = drop.chance,
							m_levelMultiplier = drop.levelMultiplier
						};
					}
				}
				return dictionary;
			}
		}

		private static readonly List<Item> registeredItems = new List<Item>();

		private static readonly Dictionary<ItemDrop, Item> itemDropMap = new Dictionary<ItemDrop, Item>();

		private static Dictionary<Item, Dictionary<string, List<Recipe>>> activeRecipes = new Dictionary<Item, Dictionary<string, List<Recipe>>>();

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(new byte[] { 1, 1, 2 })]
		private static Dictionary<Recipe, ConfigEntryBase> hiddenCraftRecipes = new Dictionary<Recipe, ConfigEntryBase>();

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(new byte[] { 1, 1, 2 })]
		private static Dictionary<Recipe, ConfigEntryBase> hiddenUpgradeRecipes = new Dictionary<Recipe, ConfigEntryBase>();

		private static Dictionary<Item, Dictionary<string, ItemConfig>> itemCraftConfigs = new Dictionary<Item, Dictionary<string, ItemConfig>>();

		private static Dictionary<Item, ConfigEntry<string>> itemDropConfigs = new Dictionary<Item, ConfigEntry<string>>();

		private Dictionary<CharacterDrop, Drop> characterDrops = new Dictionary<CharacterDrop, Drop>();

		private readonly Dictionary<ConfigEntryBase, Action> statsConfigs = new Dictionary<ConfigEntryBase, Action>();

		private static readonly ConditionalWeakTable<Requirement, RequirementQuality> requirementQuality = new ConditionalWeakTable<Requirement, RequirementQuality>();

		public static Configurability DefaultConfigurability = Configurability.Full;

		public Configurability? Configurable;

		private Configurability configurationVisible = Configurability.Full;

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)]
		private TraderConfig traderConfig;

		public readonly GameObject Prefab;

		[Description("Specifies the maximum required crafting station level to upgrade and repair the item.\nDefault is calculated from crafting station level and maximum quality.")]
		public int MaximumRequiredStationLevel = int.MaxValue;

		[Description("Assigns the item as a drop item to a creature.\nUses a creature name, a drop chance and a minimum and maximum amount.")]
		public readonly DropTargets DropsFrom = new DropTargets();

		[Description("Configures whether the item can be bought at the trader.\nDon't forget to set cost to something above 0 or the item will be sold for free.")]
		public readonly Trade Trade = new Trade();

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

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

		public Dictionary<string, ItemRecipe> Recipes = new Dictionary<string, ItemRecipe>();

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)]
		private LocalizeKey _name;

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)]
		private LocalizeKey _description;

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)]
		private static object configManager;

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)]
		private static Localization _english;

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)]
		private static BaseUnityPlugin _plugin;

		private static bool hasConfigSync = true;

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)]
		private static object _configSync;

		private Configurability configurability => Configurable ?? DefaultConfigurability;

		[Description("Specifies the resources needed to craft the item.\nUse .Add to add resources with their internal ID and an amount.\nUse one .Add for each resource type the item should need.")]
		public RequiredResourceList RequiredItems => this[""].RequiredItems;

		[Description("Specifies the resources needed to upgrade the item.\nUse .Add to add resources with their internal ID and an amount. This amount will be multipled by the item quality level.\nUse one .Add for each resource type the upgrade should need.")]
		public RequiredResourceList RequiredUpgradeItems => this[""].RequiredUpgradeItems;

		[Description("Specifies the crafting station needed to craft the item.\nUse .Add to add a crafting station, using the CraftingTable enum and a minimum level for the crafting station.\nUse one .Add for each crafting station.")]
		public CraftingStationList Crafting => this[""].Crafting;

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)]
		[Description("Specifies a config entry which toggles whether a recipe is active.")]
		public ConfigEntryBase RecipeIsActive
		{
			[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(2)]
			get
			{
				return this[""].RecipeIsActive;
			}
			[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(2)]
			set
			{
				this[""].RecipeIsActive = value;
			}
		}

		[Description("Specifies the number of items that should be given to the player with a single craft of the item.\nDefaults to 1.")]
		public int CraftAmount
		{
			get
			{
				return this[""].CraftAmount;
			}
			set
			{
				this[""].CraftAmount = value;
			}
		}

		public bool RequireOnlyOneIngredient
		{
			get
			{
				return this[""].RequireOnlyOneIngredient;
			}
			set
			{
				this[""].RequireOnlyOneIngredient = value;
			}
		}

		public float QualityResultAmountMultiplier
		{
			get
			{
				return this[""].QualityResultAmountMultiplier;
			}
			set
			{
				this[""].QualityResultAmountMultiplier = value;
			}
		}

		public ItemRecipe this[string name]
		{
			get
			{
				if (Recipes.TryGetValue(name, out var value))
				{
					return value;
				}
				return Recipes[name] = new ItemRecipe();
			}
		}

		public LocalizeKey Name
		{
			get
			{
				LocalizeKey name = _name;
				if (name != null)
				{
					return name;
				}
				SharedData shared = Prefab.GetComponent<ItemDrop>().m_itemData.m_shared;
				if (shared.m_name.StartsWith("$"))
				{
					_name = new LocalizeKey(shared.m_name);
				}
				else
				{
					string text = "$item_" + ((Object)Prefab).name.Replace(" ", "_");
					_name = new LocalizeKey(text).English(shared.m_name);
					shared.m_name = text;
				}
				return _name;
			}
		}

		public LocalizeKey Description
		{
			get
			{
				LocalizeKey description = _description;
				if (description != null)
				{
					return description;
				}
				SharedData shared = Prefab.GetComponent<ItemDrop>().m_itemData.m_shared;
				if (shared.m_description.StartsWith("$"))
				{
					_description = new LocalizeKey(shared.m_description);
				}
				else
				{
					string text = "$itemdesc_" + ((Object)Prefab).name.Replace(" ", "_");
					_description = new LocalizeKey(text).English(shared.m_description);
					shared.m_description = text;
				}
				return _description;
			}
		}

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

		private static BaseUnityPlugin plugin
		{
			get
			{
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: Expected O, but got Unknown
				if (_plugin == null)
				{
					IEnumerable<TypeInfo> source;
					try
					{
						source = Assembly.GetExecutingAssembly().DefinedTypes.ToList();
					}
					catch (ReflectionTypeLoadException ex)
					{
						source = from t in ex.Types
							where t != null
							select t.GetTypeInfo();
					}
					_plugin = (BaseUnityPlugin)Chainloader.ManagerObject.GetComponent((Type)source.First([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (TypeInfo t) => t.IsClass && typeof(BaseUnityPlugin).IsAssignableFrom(t)));
				}
				return _plugin;
			}
		}

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)]
		private static object configSync
		{
			[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(2)]
			get
			{
				if (_configSync == null && hasConfigSync)
				{
					Type type = Assembly.GetExecutingAssembly().GetType("ServerSync.ConfigSync");
					if ((object)type != null)
					{
						_configSync = Activator.CreateInstance(type, plugin.Info.Metadata.GUID + " ItemManager");
						type.GetField("CurrentVersion").SetValue(_configSync, plugin.Info.Metadata.Version.ToString());
						type.GetProperty("IsLocked").SetValue(_configSync, true);
					}
					else
					{
						hasConfigSync = false;
					}
				}
				return _configSync;
			}
		}

		private static bool GeneratedConfigsEnabled()
		{
			try
			{
				return !(((object)plugin).GetType().GetField("EnableGeneratedConfigs", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(null) is bool flag) || flag;
			}
			catch
			{
				return true;
			}
		}

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

		public Item(AssetBundle bundle, string prefabName)
			: this(PrefabManager.RegisterPrefab(bundle, prefabName, addToObjectDb: true), skipRegistering: true)
		{
		}

		public Item(GameObject prefab, bool skipRegistering = false)
		{
			if (!skipRegistering)
			{
				PrefabManager.RegisterPrefab(prefab, addToObjectDb: true);
			}
			Prefab = prefab;
			registeredItems.Add(this);
			itemDropMap[Prefab.GetComponent<ItemDrop>()] = this;
			Prefab.GetComponent<ItemDrop>().m_itemData.m_dropPrefab = Prefab;
		}

		public void ToggleConfigurationVisibility(Configurability visible)
		{
			configurationVisible = visible;
			if (itemDropConfigs.TryGetValue(this, out var value))
			{
				Toggle((ConfigEntryBase)(object)value, Configurability.Drop);
			}
			if (itemCraftConfigs.TryGetValue(this, out var value2))
			{
				foreach (ItemConfig value4 in value2.Values)
				{
					ToggleObj(value4, Configurability.Recipe);
				}
			}
			foreach (Conversion conversion in Conversions)
			{
				if (conversion.config != null)
				{
					ToggleObj(conversion.config, Configurability.Recipe);
				}
			}
			foreach (KeyValuePair<ConfigEntryBase, Action> statsConfig in statsConfigs)
			{
				Toggle(statsConfig.Key, Configurability.Stats);
				if ((visible & Configurability.Stats) != 0)
				{
					statsConfig.Value();
				}
			}
			reloadConfigDisplay();
			void Toggle(ConfigEntryBase cfg, Configurability check)
			{
				object[] tags = cfg.Description.Tags;
				for (int j = 0; j < tags.Length; j++)
				{
					if (tags[j] is ConfigurationManagerAttributes configurationManagerAttributes)
					{
						configurationManagerAttributes.Browsable = (visible & check) != 0 && (configurationManagerAttributes.browsability == null || configurationManagerAttributes.browsability());
					}
				}
			}
			void ToggleObj(object obj, Configurability check)
			{
				FieldInfo[] fields = obj.GetType().GetFields();
				for (int i = 0; i < fields.Length; i++)
				{
					object? value3 = fields[i].GetValue(obj);
					ConfigEntryBase val = (ConfigEntryBase)((value3 is ConfigEntryBase) ? value3 : null);
					if (val != null)
					{
						Toggle(val, check);
					}
				}
			}
		}

		internal static void reloadConfigDisplay()
		{
			object obj = configManager?.GetType().GetProperty("DisplayingWindow").GetValue(configManager);
			if (obj is bool && (bool)obj)
			{
				configManager.GetType().GetMethod("BuildSettingList").Invoke(configManager, Array.Empty<object>());
			}
		}

		private void UpdateItemTableConfig(string recipeKey, CraftingTable table, string customTableValue)
		{
			if (activeRecipes.ContainsKey(this) && activeRecipes[this].TryGetValue(recipeKey, out var value))
			{
				value.First().m_enabled = table != CraftingTable.Disabled;
				if ((uint)table <= 1u)
				{
					value.First().m_craftingStation = null;
				}
				else if (table == CraftingTable.Custom)
				{
					Recipe obj = value.First();
					GameObject prefab = ZNetScene.instance.GetPrefab(customTableValue);
					obj.m_craftingStation = ((prefab != null) ? prefab.GetComponent<CraftingStation>() : null);
				}
				else
				{
					value.First().m_craftingStation = ZNetScene.instance.GetPrefab(getInternalName(table)).GetComponent<CraftingStation>();
				}
			}
		}

		private void UpdateCraftConfig(string recipeKey, SerializedRequirements craftRequirements, SerializedRequirements upgradeRequirements)
		{
			if (!Object.op_Implicit((Object)(object)ObjectDB.instance) || !activeRecipes.ContainsKey(this) || !activeRecipes[this].TryGetValue(recipeKey, out var value))
			{
				return;
			}
			foreach (Recipe item in value)
			{
				item.m_resources = SerializedRequirements.toPieceReqs(ObjectDB.instance, craftRequirements, upgradeRequirements);
			}
		}

		internal static void Patch_FejdStartup()
		{
			//IL_0c3a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c3f: Unknown result type (might be due to invalid IL or missing references)
			//IL_17e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_17ea: Expected O, but got Unknown
			//IL_0ca2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ca5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cfb: Expected I4, but got Unknown
			//IL_0929: Unknown result type (might be due to invalid IL or missing references)
			//IL_0933: Expected O, but got Unknown
			//IL_0dce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dd1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dd3: Invalid comparison between Unknown and I4
			//IL_0dd5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dd9: Invalid comparison between Unknown and I4
			//IL_037c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0386: Expected O, but got Unknown
			//IL_0ddb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ddf: Invalid comparison between Unknown and I4
			//IL_0f18: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f1b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f1d: Invalid comparison between Unknown and I4
			//IL_0a4c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a56: Expected O, but got Unknown
			//IL_0af7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b01: Expected O, but got Unknown
			//IL_0f1f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f23: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f25: Invalid comparison between Unknown and I4
			//IL_046f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0479: Expected O, but got Unknown
			//IL_0bab: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bb5: Expected O, but got Unknown
			//IL_0f27: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f2b: Invalid comparison between Unknown and I4
			//IL_0f9a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f9d: Invalid comparison between Unknown and I4
			//IL_05aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b4: Expected O, but got Unknown
			//IL_119a: Unknown result type (might be due to invalid IL or missing references)
			//IL_11a1: Invalid comparison between Unknown and I4
			//IL_126a: Unknown result type (might be due to invalid IL or missing references)
			//IL_126f: Unknown result type (might be due to invalid IL or missing references)
			//IL_1271: Unknown result type (might be due to invalid IL or missing references)
			//IL_1275: Unknown result type (might be due to invalid IL or missing references)
			//IL_1277: Invalid comparison between Unknown and I4
			//IL_12e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_12e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_12eb: Invalid comparison between Unknown and I4
			//IL_12ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_12f1: Invalid comparison between Unknown and I4
			//IL_12f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_12f7: Invalid comparison between Unknown and I4
			//IL_16a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_16a5: Invalid comparison between Unknown and I4
			Type type = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (Assembly a) => a.GetName().Name == "ConfigurationManager")?.GetType("ConfigurationManager.ConfigurationManager");
			if (DefaultConfigurability != 0)
			{
				bool saveOnConfigSet = plugin.Config.SaveOnConfigSet;
				plugin.Config.SaveOnConfigSet = false;
				foreach (Item item4 in registeredItems.Where([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (Item i) => i.configurability != Configurability.Disabled))
				{
					Item item3 = item4;
					if (!GeneratedConfigsEnabled())
					{
						if (item3.Trade.Trader != 0)
						{
							PrefabManager.AddItemToTrader(item3.Prefab, item3.Trade.Trader, item3.Trade.Price, item3.Trade.Stack, item3.Trade.RequiredGlobalKey);
						}
						continue;
					}
					string name2 = item3.Prefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_name;
					string englishName = new Regex("[=\\n\\t\\\\\"\\'\\[\\]]*").Replace(english.Localize(name2), "").Trim();
					string localizedName = Localization.instance.Localize(name2).Trim();
					int order = 0;
					if ((item3.configurability & Configurability.Recipe) != 0)
					{
						itemCraftConfigs[item3] = new Dictionary<string, ItemConfig>();
						foreach (string item5 in item3.Recipes.Keys.DefaultIfEmpty(""))
						{
							string configKey = item5;
							string text = ((configKey == "") ? "" : (" (" + configKey + ")"));
							if (!item3.Recipes.ContainsKey(configKey) || item3.Recipes[configKey].Crafting.Stations.Count <= 0)
							{
								continue;
							}
							ItemConfig itemConfig2 = (itemCraftConfigs[item3][configKey] = new ItemConfig());
							ItemConfig cfg = itemConfig2;
							List<ConfigurationManagerAttributes> hideWhenNoneAttributes = new List<ConfigurationManagerAttributes>();
							cfg.table = config(englishName, "Crafting Station" + text, item3.Recipes[configKey].Crafting.Stations.First().Table, new ConfigDescription("Crafting station where " + englishName + " is available.", (AcceptableValueBase)null, new object[1]
							{
								new ConfigurationManagerAttributes
								{
									Order = (order -= 1),
									Browsable = ((item3.configurationVisible & Configurability.Recipe) != 0),
									Category = localizedName
								}
							}));
							ConfigurationManagerAttributes customTableAttributes = new ConfigurationManagerAttributes
							{
								Order = (order -= 1),
								browsability = CustomTableBrowsability,
								Browsable = (CustomTableBrowsability() && (item3.configurationVisible & Configurability.Recipe) != 0),
								Category = localizedName
							};
							cfg.customTable = config(englishName, "Custom Crafting Station" + text, item3.Recipes[configKey].Crafting.Stations.First().custom ?? "", new ConfigDescription("", (AcceptableValueBase)null, new object[1] { customTableAttributes }));
							cfg.table.SettingChanged += TableConfigChanged;
							cfg.customTable.SettingChanged += TableConfigChanged;
							ConfigurationManagerAttributes configurationManagerAttributes = new ConfigurationManagerAttributes
							{
								Order = (order -= 1),
								browsability = TableLevelBrowsability,
								Browsable = (TableLevelBrowsability() && (item3.configurationVisible & Configurability.Recipe) != 0),
								Category = localizedName
							};
							hideWhenNoneAttributes.Add(configurationManagerAttributes);
							cfg.tableLevel = config(englishName, "Crafting Station Level" + text, item3.Recipes[configKey].Crafting.Stations.First().level, new ConfigDescription("Required crafting station level to craft " + englishName + ".", (AcceptableValueBase)null, new object[1] { configurationManagerAttributes }));
							cfg.tableLevel.SettingChanged += [<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (object _, EventArgs _) =>
							{
								if (activeRecipes.ContainsKey(item3) && activeRecipes[item3].TryGetValue(configKey, out var value3))
								{
									value3.First().m_minStationLevel = cfg.tableLevel.Value;
								}
							};
							if ((!item3.Recipes[configKey].RequiredItems.Free || item3.Recipes[configKey].RequiredItems.Requirements.Count > 0) && item3.Recipes[configKey].RequiredItems.Requirements.All((Requirement r) => r.amountConfig == null))
							{
								cfg.craft = itemConfig("Crafting Costs" + text, new SerializedRequirements(item3.Recipes[configKey].RequiredItems.Requirements).ToString(), "Item costs to craft " + englishName, isUpgrade: false);
							}
							if (item3.Prefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_maxQuality > 1 && (!item3.Recipes[configKey].RequiredUpgradeItems.Free || item3.Recipes[configKey].RequiredUpgradeItems.Requirements.Count > 0) && item3.Recipes[configKey].RequiredUpgradeItems.Requirements.All((Requirement r) => r.amountConfig == null))
							{
								cfg.upgrade = itemConfig("Upgrading Costs" + text, new SerializedRequirements(item3.Recipes[configKey].RequiredUpgradeItems.Requirements).ToString(), "Item costs per level to upgrade " + englishName, isUpgrade: true);
							}
							if (cfg.craft != null)
							{
								cfg.craft.SettingChanged += ConfigChanged;
							}
							if (cfg.upgrade != null)
							{
								cfg.upgrade.SettingChanged += ConfigChanged;
							}
							void ConfigChanged(object o, EventArgs e)
							{
								item3.UpdateCraftConfig(configKey, new SerializedRequirements(cfg.craft?.Value ?? ""), new SerializedRequirements(cfg.upgrade?.Value ?? ""));
							}
							bool CustomTableBrowsability()
							{
								return cfg.table.Value == CraftingTable.Custom;
							}
							bool ItemBrowsability()
							{
								return cfg.table.Value != CraftingTable.Disabled;
							}
							void TableConfigChanged(object o, EventArgs e)
							{
								item3.UpdateItemTableConfig(configKey, cfg.table.Value, cfg.customTable.Value);
								customTableAttributes.Browsable = cfg.table.Value == CraftingTable.Custom;
								foreach (ConfigurationManagerAttributes item6 in hideWhenNoneAttributes)
								{
									item6.Browsable = cfg.table.Value != CraftingTable.Disabled;
								}
								reloadConfigDisplay();
							}
							bool TableLevelBrowsability()
							{
								return cfg.table.Value != CraftingTable.Disabled;
							}
							ConfigEntry<string> itemConfig(string name, string value, string desc, bool isUpgrade)
							{
								//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
								//IL_00b1: Expected O, but got Unknown
								ConfigurationManagerAttributes configurationManagerAttributes3 = new ConfigurationManagerAttributes
								{
									CustomDrawer = drawRequirementsConfigTable(item3, isUpgrade),
									Order = (order -= 1),
									browsability = ItemBrowsability,
									Browsable = (ItemBrowsability() && (item3.configurationVisible & Configurability.Recipe) != 0),
									Category = localizedName
								};
								hideWhenNoneAttributes.Add(configurationManagerAttributes3);
								return config(englishName, name, value, new ConfigDescription(desc, (AcceptableValueBase)null, new object[1] { configurationManagerAttributes3 }));
							}
						}
						if ((item3.configurability & Configurability.Drop) != 0)
						{
							ConfigEntry<string> val3 = (itemDropConfigs[item3] = config(englishName, "Drops from", new SerializedDrop(item3.DropsFrom.Drops).ToString(), new ConfigDescription(englishName + " drops from this creature.", (AcceptableValueBase)null, new object[1]
							{
								new ConfigurationManagerAttributes
								{
									CustomDrawer = drawDropsConfigTable,
									Category = localizedName,
									Browsable = ((item3.configurationVisible & Configurability.Drop) != 0)
								}
							})));
							val3.SettingChanged += [<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (object _, EventArgs _) =>
							{
								item3.UpdateCharacterDrop();
							};
						}
						for (int j = 0; j < item3.Conversions.Count; j++)
						{
							string text2 = ((item3.Conversions.Count > 1) ? $"{j + 1}. " : "");
							Conversion conversion = item3.Conversions[j];
							conversion.config = new Conversion.ConversionConfig();
							int index = j;
							conversion.config.input = config(englishName, text2 + "Conversion Input Item", conversion.Input, new ConfigDescription("Input item to create " + englishName, (AcceptableValueBase)null, new object[1]
							{
								new ConfigurationManagerAttributes
								{
									Category = localizedName,
									Browsable = ((item3.configurationVisible & Configurability.Recipe) != 0)
								}
							}));
							conversion.config.input.SettingChanged += [<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (object _, EventArgs _) =>
							{
								if (index < item3.conversions.Count)
								{
									ObjectDB instance = ObjectDB.instance;
									if (instance != null)
									{
										ItemDrop from = SerializedRequirements.fetchByName(instance, conversion.config.input.Value);
										item3.conversions[index].m_from = from;
										UpdatePiece();
									}
								}
							};
							conversion.config.piece = config(englishName, text2 + "Conversion Piece", conversion.Piece, new ConfigDescription("Conversion piece used to create " + englishName, (AcceptableValueBase)null, new object[1]
							{
								new ConfigurationManagerAttributes
								{
									Category = localizedName,
									Browsable = ((item3.configurationVisible & Configurability.Recipe) != 0)
								}
							}));
							conversion.config.piece.SettingChanged += [<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (object _, EventArgs _) =>
							{
								UpdatePiece();
							};
							conversion.config.customPiece = config(englishName, text2 + "Conversion Custom Piece", conversion.customPiece ?? "", new ConfigDescription("Custom conversion piece to create " + englishName, (AcceptableValueBase)null, new object[1]
							{
								new ConfigurationManagerAttributes
								{
									Category = localizedName,
									Browsable = ((item3.configurationVisible & Configurability.Recipe) != 0)
								}
							}));
							conversion.config.customPiece.SettingChanged += [<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (object _, EventArgs _) =>
							{
								UpdatePiece();
							};
							void UpdatePiece()
							{
								if (index < item3.conversions.Count && Object.op_Implicit((Object)(object)ZNetScene.instance))
								{
									string text3 = ((conversion.config.piece.Value == ConversionPiece.Disabled) ? null : ((conversion.config.piece.Value == ConversionPiece.Custom) ? conversion.config.customPiece.Value : getInternalName(conversion.config.piece.Value)));
									string activePiece = conversion.config.activePiece;
									if (conversion.config.activePiece != null)
									{
										int num = ZNetScene.instance.GetPrefab(conversion.config.activePiece).GetComponent<Smelter>().m_conversion.IndexOf(item3.conversions[index]);
										if (num >= 0)
										{
											Smelter[] array2 = Resources.FindObjectsOfTypeAll<Smelter>();
											foreach (Smelter val4 in array2)
											{
												if (Utils.GetPrefabName(((Component)val4).gameObject) == activePiece)
												{
													val4.m_conversion.RemoveAt(num);
												}
											}
										}
										conversion.config.activePiece = null;
									}
									if (item3.conversions[index].m_from != null && conversion.config.piece.Value != 0)
									{
										GameObject prefab = ZNetScene.instance.GetPrefab(text3);
										if (((prefab != null) ? prefab.GetComponent<Smelter>() : null) != null)
										{
											conversion.config.activePiece = text3;
											Smelter[] array2 = Resources.FindObjectsOfTypeAll<Smelter>();
											foreach (Smelter val5 in array2)
											{
												if (Utils.GetPrefabName(((Component)val5).gameObject) == text3)
												{
													val5.m_conversion.Add(item3.conversions[index]);
												}
											}
										}
									}
								}
							}
						}
					}
					if ((item3.configurability & Configurability.Stats) != 0)
					{
						item3.statsConfigs.Clear();
						SharedData shared2 = item3.Prefab.GetComponent<ItemDrop>().m_itemData.m_shared;
						ItemType itemType = shared2.m_itemType;
						statcfg<int>("Trader Value", "Trader value of " + englishName + ".", (SharedData shared) => shared.m_value, delegate(SharedData shared, int value)
						{
							shared.m_value = value;
						});
						bool flag;
						switch (itemType - 3)
						{
						case 0:
						case 1:
						case 2:
						case 3:
						case 4:
						case 8:
						case 9:
						case 11:
						case 14:
						case 16:
						case 19:
							flag = true;
							break;
						default:
							flag = false;
							break;
						}
						if (flag)
						{
							statcfg<float>("Durability", "Durability of " + englishName + ".", (SharedData shared) => shared.m_maxDurability, delegate(SharedData shared, float value)
							{
								shared.m_maxDurability = value;
							});
							statcfg<float>("Movement Speed Modifier", "Movement speed modifier of " + englishName + ".", (SharedData shared) => shared.m_movementModifier, delegate(SharedData shared, float value)
							{
								shared.m_movementModifier = value;
							});
						}
						if ((itemType - 3 <= 2 || (int)itemType == 14 || (int)itemType == 22) ? true : false)
						{
							statcfg<float>("Block Armor", "Block armor of " + englishName + ".", (SharedData shared) => shared.m_blockPower, delegate(SharedData shared, float value)
							{
								shared.m_blockPower = value;
							});
							statcfg<float>("Block Force", "Block force of " + englishName + ".", (SharedData shared) => shared.m_deflectionForce, delegate(SharedData shared, float value)
							{
								shared.m_deflectionForce = value;
							});
							statcfg<float>("Parry Bonus", "Parry bonus of " + englishName + ".", (SharedData shared) => shared.m_timedBlockBonus, delegate(SharedData shared, float value)
							{
								shared.m_timedBlockBonus = value;
							});
						}
						else if ((itemType - 6 <= 1 || itemType - 11 <= 1 || (int)itemType == 17) ? true : false)
						{
							statcfg<float>("Armor", "Armor of " + englishName + ".", (SharedData shared) => shared.m_armor, delegate(SharedData shared, float value)
							{
								shared.m_armor = value;
							});
						}
						if ((int)itemType == 2 && shared2.m_food > 0f)
						{
							statcfg<float>("Health", "Health value of " + englishName + ".", (SharedData shared) => shared.m_food, delegate(SharedData shared, float value)
							{
								shared.m_food = value;
							});
							statcfg<float>("Stamina", "Stamina value of " + englishName + ".", (SharedData shared) => shared.m_foodStamina, delegate(SharedData shared, float value)
							{
								shared.m_foodStamina = value;
							});
							statcfg<float>("Eitr", "Eitr value of " + englishName + ".", (SharedData shared) => shared.m_foodEitr, delegate(SharedData shared, float value)
							{
								shared.m_foodEitr = value;
							});
							statcfg<float>("Duration", "Duration of " + englishName + ".", (SharedData shared) => shared.m_foodBurnTime, delegate(SharedData shared, float value)
							{
								shared.m_foodBurnTime = value;
							});
							statcfg<float>("Health Regen", "Health regen value of " + englishName + ".", (SharedData shared) => shared.m_foodRegen, delegate(SharedData shared, float value)
							{
								shared.m_foodRegen = value;
							});
						}
						if ((int)shared2.m_skillType == 10)
						{
							statcfg<float>("Health Cost", "Health cost of " + englishName + ".", (SharedData shared) => shared.m_attack.m_attackHealth, delegate(SharedData shared, float value)
							{
								shared.m_attack.m_attackHealth = value;
							});
							statcfg<float>("Health Cost Percentage", "Health cost percentage of " + englishName + ".", (SharedData shared) => shared.m_attack.m_attackHealthPercentage, delegate(SharedData shared, float value)
							{
								shared.m_attack.m_attackHealthPercentage = value;
							});
						}
						SkillType skillType = shared2.m_skillType;
						if (skillType - 9 <= 1)
						{
							statcfg<float>("Eitr Cost", "Eitr cost of " + englishName + ".", (SharedData shared) => shared.m_attack.m_attackEitr, delegate(SharedData shared, float value)
							{
								shared.m_attack.m_attackEitr = value;
							});
						}
						if ((itemType - 3 <= 1 || (int)itemType == 14 || (int)itemType == 22) ? true : false)
						{
							statcfg<float>("Attack Stamina", "Attack stamina of " + englishName + ".", (SharedData shared) => shared.m_attack.m_attackStamina, delegate(SharedData shared, float value)
							{
								shared.m_attack.m_attackStamina = value;
							});
							SetDmg("True", (DamageTypes dmg) => dmg.m_damage, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_damage = val;
							});
							SetDmg("Slash", (DamageTypes dmg) => dmg.m_slash, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_slash = val;
							});
							SetDmg("Pierce", (DamageTypes dmg) => dmg.m_pierce, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_pierce = val;
							});
							SetDmg("Blunt", (DamageTypes dmg) => dmg.m_blunt, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_blunt = val;
							});
							SetDmg("Chop", (DamageTypes dmg) => dmg.m_chop, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_chop = val;
							});
							SetDmg("Pickaxe", (DamageTypes dmg) => dmg.m_pickaxe, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_pickaxe = val;
							});
							SetDmg("Fire", (DamageTypes dmg) => dmg.m_fire, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_fire = val;
							});
							SetDmg("Poison", (DamageTypes dmg) => dmg.m_poison, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_poison = val;
							});
							SetDmg("Frost", (DamageTypes dmg) => dmg.m_frost, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_frost = val;
							});
							SetDmg("Lightning", (DamageTypes dmg) => dmg.m_lightning, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_lightning = val;
							});
							SetDmg("Spirit", (DamageTypes dmg) => dmg.m_spirit, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_spirit = val;
							});
							if ((int)itemType == 4)
							{
								statcfg<float>("Stamina Drain", "Stamina drain per second while drawing " + englishName + ".", (SharedData shared) => shared.m_attack.m_drawStaminaDrain, delegate(SharedData shared, float value)
								{
									shared.m_attack.m_drawStaminaDrain = value;
								});
							}
						}
					}
					List<ConfigurationManagerAttributes> traderAttributes;
					if ((item3.configurability & Configurability.Trader) != 0)
					{
						traderAttributes = new List<ConfigurationManagerAttributes>();
						item3.traderConfig = new TraderConfig
						{
							trader = config(englishName, "Trader Selling", item3.Trade.Trader, new ConfigDescription("Which traders sell " + englishName + ".", (AcceptableValueBase)null, new object[1]
							{
								new ConfigurationManagerAttributes
								{
									Order = (order -= 1),
									Browsable = ((item3.configurationVisible & Configurability.Trader) != 0),
									Category = localizedName
								}
							}))
						};
						item3.traderConfig.trader.SettingChanged += [<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (object _, EventArgs _) =>
						{
							item3.ReloadTraderConfiguration();
							foreach (ConfigurationManagerAttributes item7 in traderAttributes)
							{
								item7.Browsable = TraderBrowsability();
							}
							reloadConfigDisplay();
						};
						item3.traderConfig.price = traderConfig<uint>("Trader Price", item3.Trade.Price, "Price of " + englishName + " at the trader.");
						if (item3.traderConfig.trader.Value != 0)
						{
							PrefabManager.AddItemToTrader(item3.Prefab, item3.traderConfig.trader.Value, item3.traderConfig.price.Value, item3.Trade.Stack, item3.Trade.RequiredGlobalKey);
						}
					}
					else if (item3.Trade.Trader != 0)
					{
						PrefabManager.AddItemToTrader(item3.Prefab, item3.Trade.Trader, item3.Trade.Price, item3.Trade.Stack, item3.Trade.RequiredGlobalKey);
					}
					void SetDmg(string dmgType, Func<DamageTypes, float> readDmg, setDmgFunc setDmg)
					{
						statcfg<float>(dmgType + " Damage", dmgType + " damage dealt by " + englishName + ".", (SharedData shared) => readDmg(shared.m_damages), delegate(SharedData shared, float val)
						{
							setDmg(ref shared.m_damages, val);
						});
						statcfg<float>(dmgType + " Damage Per Level", dmgType + " damage dealt increase per level for " + englishName + ".", (SharedData shared) => readDmg(shared.m_damagesPerLevel), delegate(SharedData shared, float val)
						{
							setDmg(ref shared.m_damagesPerLevel, val);
						});
					}
					bool TraderBrowsability()
					{
						return item3.traderConfig.trader.Value != Trader.None;
					}
					void statcfg<T>(string configName, string description, [<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(new byte[] { 1, 1, 0 })] Func<SharedData, T> readDefault, [<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(new byte[] { 1, 1, 0 })] Action<SharedData, T> setValue)
					{
						//IL_0078: Unknown result type (might be due to invalid IL or missing references)
						//IL_0082: Expected O, but got Unknown
						SharedData shared3 = item3.Prefab.GetComponent<ItemDrop>().m_itemData.m_shared;
						ConfigEntry<T> cfg2 = config(englishName, configName, readDefault(shared3), new ConfigDescription(description, (AcceptableValueBase)null, new object[1]
						{
							new ConfigurationManagerAttributes
							{
								Category = localizedName,
								Browsable = ((item3.configurationVisible & Configurability.Stats) != 0)
							}
						}));
						if ((item3.configurationVisible & Configurability.Stats) != 0)
						{
							setValue(shared3, cfg2.Value);
						}
						item3.statsConfigs.Add((ConfigEntryBase)(object)cfg2, ApplyConfig);
						cfg2.SettingChanged += [<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (object _, EventArgs _) =>
						{
							if ((item3.configurationVisible & Configurability.Stats) != 0)
							{
								ApplyConfig();
							}
						};
						void ApplyConfig()
						{
							item3.ApplyToAllInstances(delegate(ItemData item)
							{
								setValue(item.m_shared, cfg2.Value);
							});
						}
					}
					[return: <5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(new byte[] { 1, 0 })]
					ConfigEntry<T> traderConfig<T>(string name, [<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)] T value, string desc)
					{
						//IL_0099: Unknown result type (might be due to invalid IL or missing references)
						//IL_00a3: Expected O, but got Unknown
						ConfigurationManagerAttributes configurationManagerAttributes2 = new ConfigurationManagerAttributes
						{
							Order = (order -= 1),
							browsability = TraderBrowsability,
							Browsable = (TraderBrowsability() && (item3.configurationVisible & Configurability.Trader) != 0),
							Category = localizedName
						};
						traderAttributes.Add(configurationManagerAttributes2);
						ConfigEntry<T> obj = config(englishName, name, value, new ConfigDescription(desc, (AcceptableValueBase)null, new object[1] { configurationManagerAttributes2 }));
						obj.SettingChanged += [<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (object _, EventArgs _) =>
						{
							item3.ReloadTraderConfiguration();
						};
						return obj;
					}
				}
				if (saveOnConfigSet)
				{
					plugin.Config.SaveOnConfigSet = true;
					plugin.Config.Save();
				}
			}
			configManager = ((type == null) ? null : Chainloader.ManagerObject.GetComponent(type));
			foreach (Item registeredItem in registeredItems)
			{
				Item item2 = registeredItem;
				foreach (KeyValuePair<string, ItemRecipe> recipe in item2.Recipes)
				{
					KeyValuePair<string, ItemRecipe> kv = recipe;
					RequiredResourceList[] array = new RequiredResourceList[2]
					{
						kv.Value.RequiredItems,
						kv.Value.RequiredUpgradeItems
					};
					foreach (RequiredResourceList requiredResourceList in array)
					{
						for (int l = 0; l < requiredResourceList.Requirements.Count; l++)
						{
							ConfigEntry<int> amountCfg;
							int resourceIndex;
							if ((item2.configurability & Configurability.Recipe) != 0)
							{
								amountCfg = requiredResourceList.Requirements[l].amountConfig;
								if (amountCfg != null)
								{
									resourceIndex = l;
									amountCfg.SettingChanged += ConfigChanged;
								}
							}
							void ConfigChanged(object o, EventArgs e)
							{
								if (Object.op_Implicit((Object)(object)ObjectDB.instance) && activeRecipes.ContainsKey(item2) && activeRecipes[item2].TryGetValue(kv.Key, out var value2))
								{
									foreach (Recipe item8 in value2)
									{
										item8.m_resources[resourceIndex].m_amount = amountCfg.Value;
									}
								}
							}
						}
					}
				}
				item2.InitializeNewRegisteredItem();
			}
		}

		private void InitializeNewRegisteredItem()
		{
			foreach (KeyValuePair<string, ItemRecipe> recipe in Recipes)
			{
				KeyValuePair<string, ItemRecipe> kv = recipe;
				ConfigEntryBase enabledCfg = kv.Value.RecipeIsActive;
				if (enabledCfg != null)
				{
					((object)enabledCfg).GetType().GetEvent("SettingChanged").AddEventHandler(enabledCfg, new EventHandler(ConfigChanged));
				}
				void ConfigChanged(object o, EventArgs e)
				{
					if (Object.op_Implicit((Object)(object)ObjectDB.instance) && activeRecipes.ContainsKey(this) && activeRecipes[this].TryGetValue(kv.Key, out var value))
					{
						foreach (Recipe item in value)
						{
							item.m_enabled = (int)enabledCfg.BoxedValue != 0;
						}
					}
				}
			}
		}

		public void ReloadCraftingConfiguration()
		{
			if (Object.op_Implicit((Object)(object)ObjectDB.instance) && ObjectDB.instance.GetItemPrefab(StringExtensionMethods.GetStableHashCode(((Object)Prefab).name)) == null)
			{
				registerRecipesInObjectDB(ObjectDB.instance);
				ObjectDB.instance.m_items.Add(Prefab);
				ObjectDB.instance.m_itemByHash.Add(StringExtensionMethods.GetStableHashCode(((Object)Prefab).name), Prefab);
				ZNetScene.instance.m_prefabs.Add(Prefab);
				ZNetScene.instance.m_namedPrefabs.Add(StringExtensionMethods.GetStableHashCode(((Object)Prefab).name), Prefab);
			}
			foreach (string item in Recipes.Keys.DefaultIfEmpty(""))
			{
				if (Recipes.TryGetValue(item, out var value) && value.Crafting.Stations.Count > 0)
				{
					UpdateItemTableConfig(item, value.Crafting.Stations.First().Table, value.Crafting.Stations.First().custom ?? "");
					UpdateCraftConfig(item, new SerializedRequirements(value.RequiredItems.Requirements), new SerializedRequirements(value.RequiredUpgradeItems.Requirements));
				}
			}
		}

		private void ReloadTraderConfiguration()
		{
			if (traderConfig.trader.Value == Trader.None)
			{
				PrefabManager.RemoveItemFromTrader(Prefab);
			}
			else
			{
				PrefabManager.AddItemToTrader(Prefab, traderConfig.trader.Value, traderConfig.price.Value, Trade.Stack, Trade.RequiredGlobalKey);
			}
		}

		public static void ApplyToAllInstances(GameObject prefab, Action<ItemData> callback)
		{
			callback(prefab.GetComponent<ItemDrop>().m_itemData);
			string name = prefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_name;
			Inventory[] source = (from c in Player.s_players.Select([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (Player p) => ((Humanoid)p).GetInventory()).Concat(from c in Object.FindObjectsOfType<Container>()
					select c.GetInventory())
				where c != null
				select c).ToArray();
			foreach (ItemData item in (from i in (from p in ObjectDB.instance.m_items
					select p.GetComponent<ItemDrop>() into c
					where Object.op_Implicit((Object)(object)c) && Object.op_Implicit((Object)(object)((Component)c).GetComponent<ZNetView>())
					select c).Concat(ItemDrop.s_instances)
				select i.m_itemData).Concat(source.SelectMany([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (Inventory i) => i.GetAllItems())))
			{
				if (item.m_shared.m_name == name)
				{
					callback(item);
				}
			}
		}

		public void ApplyToAllInstances(Action<ItemData> callback)
		{
			ApplyToAllInstances(Prefab, callback);
		}

		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		[return: <5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(1)]
		private static string getInternalName<T>(T value) where T : struct
		{
			return ((InternalName)typeof(T).GetMember(value.ToString())[0].GetCustomAttributes(typeof(InternalName)).First()).internalName;
		}

		private void registerRecipesInObjectDB(ObjectDB objectDB)
		{
			//IL_0427: Unknown result type (might be due to invalid IL or missing references)
			//IL_042c: Unknown result type (might be due to invalid IL or missing references)
			//IL_045f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0475: Expected O, but got Unknown
			activeRecipes[this] = new Dictionary<string, List<Recipe>>();
			itemCraftConfigs.TryGetValue(this, out var value);
			foreach (KeyValuePair<string, ItemRecipe> recipe in Recipes)
			{
				List<Recipe> list = new List<Recipe>();
				foreach (CraftingStationConfig station in recipe.Value.Crafting.Stations)
				{
					ItemConfig itemConfig = value?[recipe.Key];
					Recipe val = ScriptableObject.CreateInstance<Recipe>();
					string name = ((Object)Prefab).name;
					CraftingTable table = station.Table;
					((Object)val).name = name + "_Recipe_" + table;
					val.m_amount = recipe.Value.CraftAmount;
					bool enabled;
					if (itemConfig != null)
					{
						enabled = itemConfig.table.Value != CraftingTable.Disabled;
					}
					else
					{
						ConfigEntryBase recipeIsActive = recipe.Value.RecipeIsActive;
						enabled = (int)(((recipeIsActive != null) ? recipeIsActive.BoxedValue : null) ?? ((object)1)) != 0;
					}
					val.m_enabled = enabled;
					val.m_item = Prefab.GetComponent<ItemDrop>();
					val.m_resources = SerializedRequirements.toPieceReqs(objectDB, (itemConfig?.craft == null) ? new SerializedRequirements(recipe.Value.RequiredItems.Requirements) : new SerializedRequirements(itemConfig.craft.Value), (itemConfig?.upgrade == null) ? new SerializedRequirements(recipe.Value.RequiredUpgradeItems.Requirements) : new SerializedRequirements(itemConfig.upgrade.Value));
					table = ((itemConfig == null || list.Count > 0) ? station.Table : itemConfig.table.Value);
					if ((uint)table <= 1u)
					{
						val.m_craftingStation = null;
					}
					else if (((itemConfig == null || list.Count > 0) ? station.Table : itemConfig.table.Value) == CraftingTable.Custom)
					{
						GameObject prefab = ZNetScene.instance.GetPrefab((itemConfig == null || list.Count > 0) ? station.custom : itemConfig.customTable.Value);
						if (prefab != null)
						{
							val.m_craftingStation = prefab.GetComponent<CraftingStation>();
						}
						else
						{
							Debug.LogWarning((object)("Custom crafting station '" + ((itemConfig == null || list.Count > 0) ? station.custom : itemConfig.customTable.Value) + "' does not exist"));
						}
					}
					else
					{
						val.m_craftingStation = ZNetScene.instance.GetPrefab(getInternalName((itemConfig == null || list.Count > 0) ? station.Table : itemConfig.table.Value)).GetComponent<CraftingStation>();
					}
					val.m_minStationLevel = ((itemConfig == null || list.Count > 0) ? station.level : itemConfig.tableLevel.Value);
					val.m_requireOnlyOneIngredient = recipe.Value.RequireOnlyOneIngredient;
					val.m_qualityResultAmountMultiplier = recipe.Value.QualityResultAmountMultiplier;
					list.Add(val);
					RequiredResourceList requiredItems = recipe.Value.RequiredItems;
					if (requiredItems != null && !requiredItems.Free)
					{
						List<Requirement> requirements = requiredItems.Requirements;
						if (requirements != null && requirements.Count == 0)
						{
							hiddenCraftRecipes.Add(val, recipe.Value.RecipeIsActive);
						}
					}
					requiredItems = recipe.Value.RequiredUpgradeItems;
					if (requiredItems != null && !requiredItems.Free)
					{
						List<Requirement> requirements = requiredItems.Requirements;
						if (requirements != null && requirements.Count == 0)
						{
							hiddenUpgradeRecipes.Add(val, recipe.Value.RecipeIsActive);
						}
					}
				}
				activeRecipes[this].Add(recipe.Key, list);
				objectDB.m_recipes.AddRange(list);
			}
			conversions = new List<ItemConversion>();
			for (int i = 0; i < Conversions.Count; i++)
			{
				Conversion conversion = Conversions[i];
				conversions.Add(new ItemConversion
				{
					m_from = SerializedRequirements.fetchByName(ObjectDB.instance, conversion.config?.input.Value ?? conversion.Input),
					m_to = Prefab.GetComponent<ItemDrop>()
				});
				ConversionPiece conversionPiece = conversion.config?.piece.Value ?? conversion.Piece;
				string text = null;
				if (conversionPiece != 0 && conversions[i].m_from != null)
				{
					text = ((conversionPiece != ConversionPiece.Custom) ? getInternalName(conversionPiece) : (conversion.config?.customPiece.Value ?? conversion.customPiece));
					GameObject prefab2 = ZNetScene.instance.GetPrefab(text);
					Smelter val2 = ((prefab2 != null) ? prefab2.GetComponent<Smelter>() : null);
					if (val2 != null)
					{
						val2.m_conversion.Add(conversions[i]);
					}
					else
					{
						text = null;
					}
				}
				if (conversion.config != null)
				{
					conversion.config.activePiece = text;
				}
			}
		}

		[HarmonyPriority(0)]
		internal static void Patch_ObjectDBInit(ObjectDB __instance)
		{
			if ((Object)(object)__instance.GetItemPrefab("YagluthDrop") == (Object)null)
			{
				return;
			}
			hiddenCraftRecipes.Clear();
			hiddenUpgradeRecipes.Clear();
			foreach (Item registeredItem in registeredItems)
			{
				registeredItem.registerRecipesInObjectDB(__instance);
			}
		}

		internal static void Patch_TraderGetAvailableItems(Trader __instance, ref List<TradeItem> __result)
		{
			string prefabName = Utils.GetPrefabName(((Component)__instance).gameObject);
			Trader trader2 = ((prefabName == "Haldor") ? Trader.Haldor : ((prefabName == "Hildir") ? Trader.Hildir : Trader.None));
			Trader trader = trader2;
			__result.AddRange(from tuple in PrefabManager.CustomTradeItems.Values
				where (tuple.Item1 & trader) != 0
				select tuple.Item2 into tradeItem
				where string.IsNullOrEmpty(tradeItem.m_requiredGlobalKey) || ZoneSystem.instance.GetGlobalKey(tradeItem.m_requiredGlobalKey)
				select tradeItem);
		}

		internal static void Patch_OnAddSmelterInput(ItemData item, bool __result)
		{
			if (__result)
			{
				((Humanoid)Player.m_localPlayer).UnequipItem(item, true);
			}
		}

		internal static void Patch_MaximumRequiredStationLevel(Recipe __instance, ref int __result, int quality)
		{
			if (!itemDropMap.TryGetValue(__instance.m_item, out var value))
			{
				return;
			}
			IEnumerable<ItemConfig> source;
			if (!itemCraftConfigs.TryGetValue(value, out var value2))
			{
				source = Enumerable.Empty<ItemConfig>();
			}
			else
			{
				CraftingStation currentCraftingStation = Player.m_localPlayer.GetCurrentCraftingStation();
				if (currentCraftingStation != null)
				{
					string stationName = Utils.GetPrefabName(((Component)currentCraftingStation).gameObject);
					source = from c in value2.Where([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (KeyValuePair<string, ItemConfig> c) =>
						{
							switch (c.Value.table.Value)
							{
							case CraftingTable.Disabled:
							case CraftingTable.Inventory:
								return false;
							case CraftingTable.Custom:
								return c.Value.customTable.Value == stationName;
							default:
								return getInternalName(c.Value.table.Value) == stationName;
							}
						})
						select c.Value;
				}
				else
				{
					source = value2.Values;
				}
			}
			__result = Mathf.Min(Mathf.Max(1, __instance.m_minStationLevel) + (quality - 1), (from cfg in source
				where cfg.maximumTableLevel != null
				select cfg.maximumTableLevel.Value).DefaultIfEmpty(value.MaximumRequiredStationLevel).Max());
		}

		internal static void Patch_GetAvailableRecipesPrefix([<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(new byte[] { 2, 1, 1, 1, 2 })] ref Dictionary<Assembly, Dictionary<Recipe, ConfigEntryBase>> __state)
		{
			if (__state == null)
			{
				__state = new Dictionary<Assembly, Dictionary<Recipe, ConfigEntryBase>>();
			}
			Dictionary<Recipe, ConfigEntryBase> dictionary;
			if (InventoryGui.instance.InCraftTab())
			{
				dictionary = hiddenCraftRecipes;
			}
			else
			{
				if (!InventoryGui.instance.InUpradeTab())
				{
					return;
				}
				dictionary = hiddenUpgradeRecipes;
			}
			foreach (Recipe key in dictionary.Keys)
			{
				key.m_enabled = false;
			}
			__state[Assembly.GetExecutingAssembly()] = dictionary;
		}

		internal static void Patch_GetAvailableRecipesFinalizer([<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(new byte[] { 1, 1, 1, 1, 2 })] Dictionary<Assembly, Dictionary<Recipe, ConfigEntryBase>> __state)
		{
			if (!__state.TryGetValue(Assembly.GetExecutingAssembly(), out var value))
			{
				return;
			}
			foreach (KeyValuePair<Recipe, ConfigEntryBase> item in value)
			{
				Recipe key = item.Key;
				ConfigEntryBase value2 = item.Value;
				key.m_enabled = (int)(((value2 != null) ? value2.BoxedValue : null) ?? ((object)1)) != 0;
			}
		}

		internal static IEnumerable<CodeInstruction> Transpile_SetupRequirementList(IEnumerable<CodeInstruction> instructionsEnumerable, ILGenerator ilg)
		{
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Expected O, but got Unknown
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Expected O, but got Unknown
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Expected O, but got Unknown
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Expected O, but got Unknown
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Expected O, but got Unknown
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Expected O, but got Unknown
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Expected O, but got Unknown
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Expected O, but got Unknown
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Expected O, but got Unknown
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Expected O, but got Unknown
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Expected O, but got Unknown
			List<CodeInstruction> list = instructionsEnumerable.ToList();
			MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(InventoryGui), "SetupRequirement", (Type[])null, (Type[])null);
			CodeInstruction val = null;
			CodeInstruction val2 = null;
			LocalBuilder localBuilder = ilg.DeclareLocal(typeof(int));
			Dictionary<Label, int> dictionary = new Dictionary<Label, int>();
			bool flag = false;
			int num = 0;
			int value = 0;
			Label? label = default(Label?);
			for (int i = 0; i < list.Count; i++)
			{
				if (CodeInstructionExtensions.Calls(list[i], methodInfo))
				{
					val = list[i + 2];
					val2 = list[i + 5];
					flag = true;
				}
				if (flag)
				{
					if (CodeInstructionExtensions.Branches(list[i], ref label) && dictionary.TryGetValue(label.Value, out value))
					{
						num = i;
						break;
					}
					continue;
				}
				foreach (Label label4 in list[i].labels)
				{
					dictionary[label4] = i;
				}
			}
			if (list[value - 3].opcode == OpCodes.Dup)
			{
				return list;
			}
			Label label2 = ilg.DefineLabel();
			Label label3 = ilg.DefineLabel();
			list[num + 1].labels.Add(label2);
			list.InsertRange(num + 1, (IEnumerable<CodeInstruction>)(object)new CodeInstruction[11]
			{
				new CodeInstruction(OpCodes.Ldloc, (object)localBuilder),
				new CodeInstruction(OpCodes.Brfalse, (object)label2),
				val.Clone(),
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.DeclaredField(typeof(InventoryGui), "m_recipeRequirementList")),
				new CodeInstruction(OpCodes.Ldlen, (object)null),
				new CodeInstruction(OpCodes.Bgt, (object)label2),
				new CodeInstruction(OpCodes.Ldc_I4_0, (object)null),
				val2.Clone(),
				new CodeInstruction(OpCodes.Ldc_I4_0, (object)null),
				new CodeInstruction(OpCodes.Br, (object)label3)
			});
			list.InsertRange(value - 2, (IEnumerable<CodeInstruction>)(object)new CodeInstruction[2]
			{
				new CodeInstruction(OpCodes.Dup, (object)null)
				{
					labels = new List<Label> { label3 }
				},
				new CodeInstruction(OpCodes.Stloc, (object)localBuilder)
			});
			return list;
		}

		internal static bool Patch_RequirementGetAmount(Requirement __instance, int qualityLevel, ref int __result)
		{
			if (requirementQuality.TryGetValue(__instance, out var value))
			{
				__result = ((value.quality == qualityLevel) ? __instance.m_amountPerLevel : 0);
				return false;
			}
			return true;
		}

		internal static void Patch_ZNetSceneAwake(ZNetScene __instance)
		{
			foreach (Item registeredItem in registeredItems)
			{
				registeredItem.AssignDropToCreature();
			}
		}

		public void AssignDropToCreature()
		{
			foreach (KeyValuePair<CharacterDrop, Drop> characterDrop in characterDrops)
			{
				if (Object.op_Implicit((Object)(object)characterDrop.Key))
				{
					characterDrop.Key.m_drops.Remove(characterDrop.Value);
				}
			}
			characterDrops.Clear();
			SerializedDrop serializedDrop = new SerializedDrop(DropsFrom.Drops);
			if (itemDropConfigs.TryGetValue(this, out var value))
			{
				serializedDrop = new SerializedDrop(value.Value);
			}
			foreach (KeyValuePair<Character, Drop> item in serializedDrop.toCharacterDrops(ZNetScene.s_instance, Prefab))
			{
				CharacterDrop val = ((Component)item.Key).GetComponent<CharacterDrop>();
				if (val == null)
				{
					val = ((Component)item.Key).gameObject.AddComponent<CharacterDrop>();
				}
				val.m_drops.Add(item.Value);
				characterDrops.Add(val, item.Value);
			}
		}

		public void UpdateCharacterDrop()
		{
			if (Object.op_Implicit((Object)(object)ZNetScene.instance))
			{
				AssignDropToCreature();
			}
		}

		public void Snapshot(float lightIntensity = 1.3f, Quaternion? cameraRotation = null, Quaternion? itemRotation = null)
		{
			SnapshotItem(Prefab.GetComponent<ItemDrop>(), lightIntensity, cameraRotation, itemRotation);
		}

		public static void SnapshotItem(ItemDrop item, float lightIntensity = 1.3f, Quaternion? cameraRotation = null, Quaternion? itemRotation = null)
		{
			if (Object.op_Implicit((Object)(object)ObjectDB.instance))
			{
				Do();
			}
			else
			{
				((MonoBehaviour)plugin).StartCoroutine(Delay());
			}
			IEnumerator Delay()
			{
				yield return null;
				Do();
			}
			void Do()
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_016a: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_0201: Unknown result type (might be due to invalid IL or missing references)
				//IL_0206: Unknown result type (might be due to invalid IL or missing references)
				//IL_0223: Unknown result type (might be due to invalid IL or missing references)
				//IL_022a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0236: Unknown result type (might be due to invalid IL or missing references)
				//IL_023d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0277: Unknown result type (might be due to invalid IL or missing references)
				//IL_0279: Unknown result type (might be due to invalid IL or missing references)
				//IL_027b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0285: Unknown result type (might be due to invalid IL or missing references)
				//IL_028a: Unknown result type (might be due to invalid IL or missing references)
				//IL_028e: Unknown result type (might be due to invalid IL or missing references)
				//IL_029a: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
				//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_031c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0323: Expected O, but got Unknown
				//IL_0325: Unknown result type (might be due to invalid IL or missing references)
				//IL_0353: Unknown result type (might be due to invalid IL or missing references)
				//IL_035e: Unknown result type (might be due to invalid IL or missing references)
				Camera component = new GameObject("Camera", new Type[1] { typeof(Camera) }).GetComponent<Camera>();
				component.backgroundColor = Color.clear;
				component.clearFlags = (CameraClearFlags)2;
				component.fieldOfView = 0.5f;
				component.farClipPlane = 10000000f;
				component.cullingMask = 1073741824;
				((Component)component).transform.rotation = (Quaternion)(((??)cameraRotation) ?? Quaternion.Euler(90f, 0f, 45f));
				Light component2 = new GameObject("Light", new Type[1] { typeof(Light) }).GetComponent<Light>();
				((Component)component2).transform.rotation = Quaternion.Euler(150f, 0f, -5f);
				component2.type = (LightType)1;
				component2.cullingMask = 1073741824;
				component2.intensity = lightIntensity;
				Rect val = default(Rect);
				((Rect)(ref val))..ctor(0f, 0f, 64f, 64f);
				Transform val2 = ((Component)item).transform.Find("attach");
				GameObject val3;
				if (val2 != null)
				{
					val3 = Object.Instantiate<GameObject>(((Component)val2).gameObject);
				}
				else
				{
					ZNetView.m_forceDisableInit = true;
					val3 = Object.Instantiate<GameObject>(((Component)item).gameObject);
					ZNetView.m_forceDisableInit = false;
				}
				if (itemRotation.HasValue)
				{
					val3.transform.rotation = itemRotation.Value;
				}
				Transform[] componentsInChildren = val3.GetComponentsInChildren<Transform>();
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					((Component)componentsInChildren[i]).gameObject.layer = 30;
				}
				Renderer[] componentsInChildren2 = val3.GetComponentsInChildren<Renderer>();
				Vector3 val4 = componentsInChildren2.Aggregate<Renderer, Vector3>(Vector3.positiveInfinity, [<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (Vector3 cur, Renderer renderer) =>
				{
					//IL_001d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0008: Unknown result type (might be due to invalid IL or missing references)
					//IL_000a: Unknown result type (might be due to invalid IL or missing references)
					//IL_000f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0012: Unknown result type (might be due to invalid IL or missing references)
					//IL_0017: Unknown result type (might be due to invalid IL or missing references)
					if (!(renderer is ParticleSystemRenderer))
					{
						Bounds bounds2 = renderer.bounds;
						return Vector3.Min(cur, ((Bounds)(ref bounds2)).min);
					}
					return cur;
				});
				Vector3 val5 = componentsInChildren2.Aggregate<Renderer, Vector3>(Vector3.negativeInfinity, [<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (Vector3 cur, Renderer renderer) =>
				{
					//IL_001d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0008: Unknown result type (might be due to invalid IL or missing references)
					//IL_000a: Unknown result type (might be due to invalid IL or missing references)
					//IL_000f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0012: Unknown result type (might be due to invalid IL or missing references)
					//IL_0017: Unknown result type (might be due to invalid IL or missing references)
					if (!(renderer is ParticleSystemRenderer))
					{
						Bounds bounds = renderer.bounds;
						return Vector3.Max(cur, ((Bounds)(ref bounds)).max);
					}
					return cur;
				});
				Vector3 val6 = val5 - val4;
				component.targetTexture = RenderTexture.GetTemporary((int)((Rect)(ref val)).width, (int)((Rect)(ref val)).height);
				float num = Mathf.Max(val6.x, val6.z);
				float num2 = Mathf.Min(val6.x, val6.z);
				float num3 = (num + num2) / Mathf.Sqrt(2f) / Mathf.Tan(component.fieldOfView * ((float)Math.PI / 180f));
				Transform transform = ((Component)component).transform;
				Vector3 val7 = (val4 + val5) / 2f;
				val7.y = val5.y;
				transform.position = val7 + new Vector3(0f, num3, 0f);
				((Component)component2).transform.position = transform.position + new Vector3(-2f, 0f, 0.2f) / 3f * (0f - num3);
				component.Render();
				RenderTexture active = RenderTexture.active;
				RenderTexture.active = component.targetTexture;
				Texture2D val8 = new Texture2D((int)((Rect)(ref val)).width, (int)((Rect)(ref val)).height, (TextureFormat)4, false);
				val8.ReadPixels(val, 0, 0);
				val8.Apply();
				RenderTexture.active = active;
				item.m_itemData.m_shared.m_icons = (Sprite[])(object)new Sprite[1] { Sprite.Create(val8, val, new Vector2(0.5f, 0.5f)) };
				Object.DestroyImmediate((Object)(object)val3);
				component.targetTexture.Release();
				Object.Destroy((Object)(object)component);
				Object.Destroy((Object)(object)component2);
			}
		}

		private static bool CheckItemIsUpgrade(InventoryGui gui)
		{
			ItemData itemData = ((RecipeDataPair)(ref gui.m_selectedRecipe)).ItemData;
			if (itemData == null)
			{
				return false;
			}
			return itemData.m_quality > 0;
		}

		internal static IEnumerable<CodeInstruction> Transpile_InventoryGui(IEnumerable<CodeInstruction> instructions)
		{
			List<CodeInstruction> instrs = instructions.ToList();
			FieldInfo amountField = AccessTools.DeclaredField(typeof(Recipe), "m_amount");
			int i = 0;
			while (i < instrs.Count)
			{
				yield return instrs[i];
				if (i > 1 && instrs[i - 2].opcode == OpCodes.Ldfld && CodeInstructionExtensions.OperandIs(instrs[i - 2], (MemberInfo)amountField) && instrs[i - 1].opcode == OpCodes.Ldc_I4_1 && instrs[i].operand is Label)
				{
					yield return new CodeInstruction(OpCodes.Ldarg_0, (object)null);
					yield return new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(Item), "CheckItemIsUpgrade", (Type[])null, (Type[])null));
					yield return new CodeInstruction(OpCodes.Brtrue, instrs[i].operand);
				}
				int num = i + 1;
				i = num;
			}
		}

		private static Action<ConfigEntryBase> drawRequirementsConfigTable(Item item, bool isUpgrade)
		{
			return delegate(ConfigEntryBase cfg)
			{
				bool locked = cfg.Description.Tags.Select([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (object a) => (!(a.GetType().Name == "ConfigurationManagerAttributes")) ? null : ((bool?)a.GetType().GetField("ReadOnly")?.GetValue(a))).FirstOrDefault((bool? v) => v.HasValue).GetValueOrDefault();
				List<Requirement> newReqs = new List<Requirement>();
				bool wasUpdated = false;
				int RightColumnWidth = (int)(configManager?.GetType().GetProperty("RightColumnWidth", BindingFlags.Instance | BindingFlags.NonPublic).GetGetMethod(nonPublic: true)
					.Invoke(configManager, Array.Empty<object>()) ?? ((object)130));
				GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
				List<Requirement> reqs = new SerializedRequirements((string)cfg.BoxedValue).Reqs;
				bool flag = false;
				int maxQuality = item.Prefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_maxQuality;
				if (isUpgrade && maxQuality > 2)
				{
					flag = reqs.Any((Requirement r) => r.quality > 0);
					if (flag)
					{
						int count = reqs.Count;
						for (int i = 0; i < count; i++)
						{
							if (reqs[i].quality == 0)
							{
								List<Requirement> list = reqs;
								int index = i;
								Requirement value = reqs[i];
								value.quality = 2;
								list[index] = value;
								for (int j = 3; j <= maxQuality; j++)
								{
									List<Requirement> list2 = reqs;
									value = reqs[i];
									value.quality = j;
									list2.Add(value);
								}
							}
						}
					}
					if (flag != GUILayout.Toggle(flag, "Individual costs per upgrade level", Array.Empty<GUILayoutOption>()))
					{
						flag = !flag;
						wasUpdated = true;
						if (flag)
						{
							int count2 = reqs.Count;
							for (int k = 0; k < count2; k++)
							{
								List<Requirement> list3 = reqs;
								int index2 = k;
								Requirement value = reqs[k];
								value.quality = 2;
								list3[index2] = value;
								for (int l = 3; l <= maxQuality; l++)
								{
									List<Requirement> list4 = reqs;
									value = reqs[k];
									value.quality = l;
									list4.Add(value);
								}
							}
						}
						else
						{
							reqs.RemoveAll((Requirement req) => req.quality > 1);
							for (int m = 0; m < reqs.Count; m++)
							{
								List<Requirement> list5 = reqs;
								int index3 = m;
								Requirement value = reqs[m];
								value.quality = 0;
								list5[index3] = value;
							}
						}
					}
				}
				if (flag)
				{
					for (int n = 2; n <= maxQuality; n++)
					{
						GUILayout.Label($"Upgrade level {n - 1}:", Array.Empty<GUILayoutOption>());
						DisplayQuality(n);
					}
				}
				else
				{
					DisplayQuality(0);
				}
				GUILayout.EndVertical();
				if (wasUpdated)
				{
					cfg.BoxedValue = new SerializedRequirements(newReqs).ToString();
				}
				void DisplayQuality(int quality)
				{
					//IL_006c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0071: Unknown result type (might be due to invalid IL or missing references)
					//IL_0086: Expected O, but got Unknown
					//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
					//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
					//IL_00e0: Expected O, but got Unknown
					//IL_0123: Unknown result type (might be due to invalid IL or missing references)
					//IL_0128: Unknown result type (might be due to invalid IL or missing references)
					//IL_013d: Expected O, but got Unknown
					//IL_0193: Unknown result type (might be due to invalid IL or missing references)
					//IL_0198: Unknown result type (might be due to invalid IL or missing references)
					//IL_01ad: Expected O, but got Unknown
					foreach (Requirement item2 in reqs.Where((Requirement r) => r.quality == quality))
					{
						GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
						int num = item2.amount;
						if (int.TryParse(GUILayout.TextField(num.ToString(), new GUIStyle(GUI.skin.textField)
						{
							fixedWidth = 40f
						}, Array.Empty<GUILayoutOption>()), out var result) && result != num && !locked)
						{
							num = result;
							wasUpdated = true;
						}
						string text = GUILayout.TextField(item2.itemName, new GUIStyle(GUI.skin.textField)
						{
							fixedWidth = RightColumnWidth - 40 - 21 - 21 - 9
						}, Array.Empty<GUILayoutOption>());
						string text2 = (locked ? item2.itemName : text);
						wasUpdated = wasUpdated || text2 != item2.itemName;
						if (GUILayout.Button("x", new GUIStyle(GUI.skin.button)
						{
							fixedWidth = 21f
						}, Array.Empty<GUILayoutOption>()) && !locked)
						{
							wasUpdated = true;
						}
						else
						{
							newReqs.Add(new Requirement
							{
								amount = num,
								itemName = text2,
								quality = quality
							});
						}
						if (GUILayout.Button("+", new GUIStyle(GUI.skin.button)
						{
							fixedWidth = 21f
						}, Array.Empty<GUILayoutOption>()) && !locked)
						{
							wasUpdated = true;
							newReqs.Add(new Requirement
							{
								amount = 1,
								itemName = "",
								quality = quality
							});
						}
						GUILayout.EndHorizontal();
					}
				}
			};
		}

		private static void drawDropsConfigTable(ConfigEntryBase cfg)
		{
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Expected O, but got Unknown
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Expected O, but got Unknown
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Expected O, but got Unknown
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Expected O, but got Unknown
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_028d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Expected O, but got Unknown
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fd: Expected O, but got Unknown
			bool valueOrDefault = cfg.Description.Tags.Select([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (object a) => (!(a.GetType().Name == "ConfigurationManagerAttributes")) ? null : ((bool?)a.GetType().GetField("ReadOnly")?.GetValue(a))).FirstOrDefault((bool? v) => v.HasValue).GetValueOrDefault();
			List<DropTarget> list = new List<DropTarget>();
			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(Array.Empty<GUILayoutOption>());
			foreach (DropTarget item in new SerializedDrop((string)cfg.BoxedValue).Drops.DefaultIfEmpty(new DropTarget
			{
				min = 1,
				max = 1,
				creature = "",
				chance = 1f
			}))
			{
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				string text = GUILayout.TextField(item.creature, new GUIStyle(GUI.skin.textField)
				{
					fixedWidth = num - 21 - 21 - 6
				}, Array.Empty<GUILayoutOption>());
				string text2 = (valueOrDefault ? item.creature : text);
				flag = flag || text2 != item.creature;
				bool num2 = GUILayout.Button("x", new GUIStyle(GUI.skin.button)
				{
					fixedWidth = 21f
				}, Array.Empty<GUILayoutOption>());
				bool flag2 = GUILayout.Button("+", new GUIStyle(GUI.skin.button)
				{
					fixedWidth = 21f
				}, Array.Empty<GUILayoutOption>());
				GUILayout.EndHorizontal();
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				GUILayout.Label("Chance: ", Array.Empty<GUILayoutOption>());
				float num3 = item.chance;
				if (float.TryParse(GUILayout.TextField((num3 * 100f).ToString(CultureInfo.InvariantCulture), new GUIStyle(GUI.skin.textField)
				{
					fixedWidth = 45f
				}, Array.Empty<GUILayoutOption>()), NumberStyles.Float, CultureInfo.InvariantCulture, out var result) && !Mathf.Approximately(result / 100f, num3) && !valueOrDefault)
				{
					num3 = result / 100f;
					flag = true;
				}
				GUILayout.Label("% Amount: ", Array.Empty<GUILayoutOption>());
				int num4 = item.min;
				if (int.TryParse(GUILayout.TextField(num4.ToString(), new GUIStyle(GUI.skin.textField)
				{
					fixedWidth = 35f
				}, Array.Empty<GUILayoutOption>()), out var result2) && result2 != num4 && !valueOrDefault)
				{
					num4 = result2;
					flag = true;
				}
				GUILayout.Label(" - ", Array.Empty<GUILayoutOption>());
				int num5 = item.max;
				if (int.TryParse(GUILayout.TextField(num5.ToString(), new GUIStyle(GUI.skin.textField)
				{
					fixedWidth = 35f
				}, Array.Empty<GUILayoutOption>()), out var result3) && result3 != num5 && !valueOrDefault)
				{
					num5 = result3;
					flag = true;
				}
				GUILayout.EndHorizontal();
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				bool flag3 = item.levelMultiplier;
				if (GUILayout.Toggle(flag3, "Level scaling drop amount", Array.Empty<GUILayoutOption>()) != flag3)
				{
					flag3 = !flag3;
					flag = true;
				}
				GUILayout.EndHorizontal();
				if (num2 && !valueOrDefault)
				{
					flag = true;
				}
				else
				{
					list.Add(new DropTarget
					{
						creature = text2,
						min = num4,
						max = num5,
						chance = num3,
						levelMultiplier = flag3
					});
				}
				if (flag2 && !valueOrDefault)
				{
					flag = true;
					list.Add(new DropTarget
					{
						min = 1,
						max = 1,
						creature = "",
						chance = 1f,
						levelMultiplier = true
					});
				}
			}
			GUILayout.EndVertical();
			if (flag)
			{
				cfg.BoxedValue = new SerializedDrop(list).ToString();
			}
		}

		private static ConfigEntry<T> config<[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)] T>(string group, string name, T value, ConfigDescription description)
		{
			ConfigEntry<T> val = plugin.Config.Bind<T>(group, name, value, description);
			configSync?.GetType().GetMethod("AddConfigEntry").MakeGenericMethod(typeof(T))
				.Invoke(configSync, new object[1] { val });
			return val;
		}

		private static ConfigEntry<T> config<[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)] T>(string group, string name, T value, string description)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			return config(group, name, value, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()));
		}
	}
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[PublicAPI]
	public 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));
				}
			}
		}
	}
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	public 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([<702532f4-32dc-46a6-8d9a-cabd38c9424b>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([<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)] string language = null)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			if (localizations.TryGetValue(language ?? PlayerPrefs.GetString("language", "English"), out var value))
			{
				return value;
			}
			value = new Localization();
			if (language != null)
			{
				value.SetupLanguage(language);
			}
			return value;
		}
	}
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	[PublicAPI]
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	public static class PrefabManager
	{
		[<5ea91132-7291-4072-bba1-fdb04647c6e6>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> prefabs;

		private static readonly List<GameObject> ZnetOnlyPrefabs;

		internal static readonly Dictionary<GameObject, Tuple<Trader, TradeItem>> CustomTradeItems;

		static PrefabManager()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Expected O, but got Unknown
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Expected O, but got Unknown
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Expected O, but got Unknown
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Expected O, but got Unknown
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Expected O, but got Unknown
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Expected O, but got Unknown
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Expected O, but got Unknown
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Expected O, but got Unknown
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_027b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0289: Expected O, but got Unknown
			//IL_028a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02df: Expected O, but got Unknown
			//IL_02df: Expected O, but got Unknown
			//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_030e: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Expected O, but got Unknown
			//IL_031c: Unknown result type (might be due to invalid IL or missing references)
			//IL_034a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0357: Expected O, but got Unknown
			//IL_0358: Unknown result type (might be due to invalid IL or missing references)
			//IL_0386: Unknown result type (might be due to invalid IL or missing references)
			//IL_0393: Expected O, but got Unknown
			//IL_0394: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cf: Expected O, but got Unknown
			//IL_03d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_040b: Expected O, but got Unknown
			//IL_0439: Unknown result type (might be due to invalid IL or missing references)
			//IL_0446: Expected O, but got Unknown
			bundleCache = new Dictionary<BundleId, AssetBundle>();
			prefabs = new List<GameObject>();
			ZnetOnlyPrefabs = new List<GameObject>();
			CustomTradeItems = new Dictionary<GameObject, Tuple<Trader, TradeItem>>();
			Harmony val = new Harmony("org.bepinex.helpers.ItemManager");
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ObjectDB), "CopyOtherDB", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PrefabManager), "Patch_ObjectDBInit", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ObjectDB), "Awake", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PrefabManager), "Patch_ObjectDBInit", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ObjectDB), "CopyOtherDB", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_ObjectDBInit", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ObjectDB), "Awake", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_ObjectDBInit", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(FejdStartup), "Awake", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_FejdStartup", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ZNetScene), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_ZNetSceneAwake", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ZNetScene), "Awake", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PrefabManager), "Patch_ZNetSceneAwake", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(InventoryGui), "UpdateRecipe", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Transpile_InventoryGui", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(InventoryGui), "SetupRequirementList", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Transpile_SetupRequirementList", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Requirement), "GetAmount", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_RequirementGetAmount", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Player), "GetAvailableRecipes", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_GetAvailableRecipesPrefix", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_GetAvailableRecipesFinalizer", (Type[])null, (Type[])null)), (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Recipe), "GetRequiredStationLevel", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_MaximumRequiredStationLevel", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Smelter), "OnAddFuel", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_OnAddSmelterInput", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Smelter), "OnAddOre", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_OnAddSmelterInput", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Trader), "GetAvailableItems", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_TraderGetAvailableItems", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Localization), "SetupLanguage", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(LocalizationCache), "LocalizationPostfix", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Localization), "LoadCSV", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(LocalizeKey), "AddLocalizedKeys", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		public static AssetBundle RegisterAssetBundle(string assetBundleFileName, string folderName = "assets")
		{
			BundleId bundleId = default(BundleId);
			bundleId.assetBundleFileName = assetBundleFileName;
			bundleId.folderName = folderName;
			BundleId key = bundleId;
			if (!bundleCache.TryGetValue(key, out var value))
			{
				Dictionary<BundleId, AssetBundle> dictionary = bundleCache;
				AssetBundle? obj = ((IEnumerable<AssetBundle>)Resources.FindObjectsOfTypeAll<AssetBundle>()).FirstOrDefault((Func<AssetBundle, bool>)([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (AssetBundle a) => ((Object)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 GameObject RegisterPrefab(string assetBundleFileName, string prefabName, string folderName = "assets")
		{
			return RegisterPrefab(RegisterAssetBundle(assetBundleFileName, folderName), prefabName);
		}

		public static GameObject RegisterPrefab(AssetBundle assets, string prefabName, bool addToObjectDb = false)
		{
			return RegisterPrefab(assets.LoadAsset<GameObject>(prefabName), addToObjectDb);
		}

		public static GameObject RegisterPrefab(GameObject prefab, bool addToObjectDb = false)
		{
			if (addToObjectDb)
			{
				prefabs.Add(prefab);
			}
			else
			{
				ZnetOnlyPrefabs.Add(prefab);
			}
			return prefab;
		}

		public static void AddItemToTrader(GameObject prefab, Trader trader, uint price, uint stack = 1u, [<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)] string requiredGlobalKey = null)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			CustomTradeItems[prefab] = new Tuple<Trader, TradeItem>(trader, new TradeItem
			{
				m_prefab = prefab.GetComponent<ItemDrop>(),
				m_price = (int)price,
				m_stack = (int)stack,
				m_requiredGlobalKey = (requiredGlobalKey ?? "")
			});
		}

		public static void RemoveItemFromTrader(GameObject prefab)
		{
			CustomTradeItems.Remove(prefab);
		}

		[HarmonyPriority(700)]
		private static void Patch_ObjectDBInit(ObjectDB __instance)
		{
			foreach (GameObject prefab in prefabs)
			{
				if (!__instance.m_items.Contains(prefab))
				{
					__instance.m_items.Add(prefab);
				}
				SharedData shared = prefab.GetComponent<ItemDrop>().m_itemData.m_shared;
				RegisterStatusEffect(shared.m_attackStatusEffect);
				RegisterStatusEffect(shared.m_consumeStatusEffect);
				RegisterStatusEffect(shared.m_equipStatusEffect);
				RegisterStatusEffect(shared.m_setStatusEffect);
			}
			__instance.UpdateRegisters();
			[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(2)]
			void RegisterStatusEffect(StatusEffect statusEffect)
			{
				if (statusEffect != null && !Object.op_Implicit((Object)(object)__instance.GetStatusEffect(StringExtensionMethods.GetStableHashCode(((Object)statusEffect).name))))
				{
					__instance.m_StatusEffects.Add(statusEffect);
				}
			}
		}

		[HarmonyPriority(700)]
		private static void Patch_ZNetSceneAwake(ZNetScene __instance)
		{
			foreach (GameObject item in prefabs.Concat(ZnetOnlyPrefabs))
			{
				if (!__instance.m_prefabs.Contains(item))
				{
					__instance.m_prefabs.Add(item);
				}
				else
				{
					Debug.LogWarning((object)("ZNetScene already contains " + ((Object)item).name + " it cannot be added twice."));
				}
			}
		}
	}
	[PublicAPI]
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(2)]
	public class Conversion
	{
		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
		internal class ConversionConfig
		{
			public ConfigEntry<string> input;

			[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)]
			public string activePiece;

			public ConfigEntry<ConversionPiece> piece;

			public ConfigEntry<string> customPiece;
		}

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(1)]
		public string Input;

		public ConversionPiece Piece;

		internal string customPiece;

		internal ConversionConfig config;

		public string Custom
		{
			get
			{
				return customPiece;
			}
			set
			{
				customPiece = value;
				Piece = ConversionPiece.Custom;
			}
		}

		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
		public Conversion(Item outputItem)
		{
			outputItem.Conversions.Add(this);
		}
	}
}
namespace StationLevelFix
{
	[HarmonyPatch(typeof(CraftingStation), "GetLevel")]
	public static class UnlimitedStationLevel
	{
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
		private static void Postfix(CraftingStation __instance, ref int __result)
		{
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "CanRepair")]
	public static class UnlimitedRepairFix
	{
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
		private static void Postfix(ItemData item, ref bool __result)
		{
			if (!__result && (Object)(object)Player.m_localPlayer != (Object)null)
			{
				CraftingStation currentCraftingStation = Player.m_localPlayer.GetCurrentCraftingStation();
				if ((Object)(object)currentCraftingStation != (Object)null && currentCraftingStation.GetLevel(true) > 4)
				{
					__result = true;
				}
			}
		}
	}
}
namespace Dreanegade.CombatPatches
{
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	public static class HealthLowBlockUseFix
	{
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		[HarmonyPatch(typeof(Attack), "Start")]
		public static class Attack_Start_HealthLowBlockUse_Patch
		{
			[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
			private static bool Prefix(Attack __instance, Humanoid character, Rigidbody body, ZSyncAnimation zanim, CharacterAnimEvent animEvent, VisEquipment visEquipment, ItemData weapon, Attack previousAttack, float timeSinceLastAttack, float attackDrawPercentage, ref bool __result)
			{
				try
				{
					Player val = (Player)(object)((character is Player) ? character : null);
					if (val == null)
					{
						return true;
					}
					if (weapon == null || (Object)(object)weapon.m_dropPrefab == (Object)null)
					{
						return true;
					}
					string prefabName = Utils.GetPrefabName(weapon.m_dropPrefab);
					if (!PatchedWeapons.Contains(prefabName))
					{
						return true;
					}
					if (AttackGetAttackHealthMethod == null || AttackHealthLowBlockUseField == null || AttackCharacterField == null || AttackWeaponField == null)
					{
						return true;
					}
					if (!(bool)AttackHealthLowBlockUseField.GetValue(__instance))
					{
						return true;
					}
					AttackCharacterField.SetValue(__instance, character);
					AttackWeaponField.SetValue(__instance, weapon);
					float num = (float)AttackGetAttackHealthMethod.Invoke(__instance, null);
					if (num <= 0f)
					{
						return true;
					}
					if (!((Character)val).HaveHealth(num + 0.1f))
					{
						Hud.instance.FlashHealthBar();
						__result = false;
						return false;
					}
					return true;
				}
				catch (Exception arg)
				{
					Debug.LogError((object)$"[HealthLowBlockUseFix] Error in Attack.Start prefix: {arg}");
					return true;
				}
			}
		}

		public static readonly HashSet<string> PatchedWeapons = new HashSet<string> { "StaffBloodcallerHealDO", "StaffBloodcallerShotgunDO" };

		private static readonly MethodInfo AttackGetAttackHealthMethod = AccessTools.Method(typeof(Attack), "GetAttackHealth", (Type[])null, (Type[])null);

		private static readonly FieldInfo AttackHealthLowBlockUseField = AccessTools.Field(typeof(Attack), "m_attackHealthLowBlockUse");

		private static readonly FieldInfo AttackCharacterField = AccessTools.Field(typeof(Attack), "m_character");

		private static readonly FieldInfo AttackWeaponField = AccessTools.Field(typeof(Attack), "m_weapon");
	}
}
namespace Dreanegade.AoePatches
{
	public static class AoeGhostDisable
	{
		[HarmonyPatch(typeof(Piece))]
		[HarmonyPatch("Awake")]
		private static class Piece_Awake_Patch
		{
			[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
			private static void Postfix(Piece __instance)
			{
				try
				{
					if ((Object)(object)__instance == (Object)null)
					{
						return;
					}
					GameObject gameObject = ((Component)__instance).gameObject;
					if ((Object)(object)gameObject == (Object)null)
					{
						return;
					}
					string prefabName = Utils.GetPrefabName(gameObject);
					if (!GhostAoePieces.Contains(prefabName))
					{
						return;
					}
					ZNetView component = gameObject.GetComponent<ZNetView>();
					if (!((Object)(object)component == (Object)null) && component.GetZDO() != null)
					{
						return;
					}
					Aoe[] componentsInChildren = gameObject.GetComponentsInChildren<Aoe>(true);
					if (componentsInChildren == null || componentsInChildren.Length == 0)
					{
						return;
					}
					Aoe[] array = componentsInChildren;
					foreach (Aoe val in array)
					{
						if ((Object)(object)val != (Object)null && ((Behaviour)val).enabled)
						{
							((Behaviour)val).enabled = false;
						}
					}
				}
				catch (Exception arg)
				{
					Debug.LogError((object)$"[AoeGhostDisable] Error in Piece_Awake_Patch: {arg}");
				}
			}
		}

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(1)]
		private static readonly HashSet<string> GhostAoePieces = new HashSet<string> { "MagicWeaverExt4DO", "MagicWeaverExt5DO" };
	}
}
namespace Magic_Supremacy
{
	public enum AirMobilityMode
	{
		VerticalBoost,
		ForwardDashAir
	}
	public enum AirMobilityDirectionMode
	{
		CharacterForward,
		LookDirection,
		MoveDirection
	}
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	public sealed class AirMobilityDef
	{
		public string DefName = "";

		public string RequiredSEName = "";

		public AirMobilityMode Mode;

		public AirMobilityDirectionMode DirectionMode;

		public float StaminaCost;

		public float EitrCost;

		public float AdrenalineCost;

		public string JumpFxPrefabName = "";

		public string AttachedFxPrefabName = "";

		public bool RequireJumpRelease = true;

		public float MinAirborneTimeBeforeRelease = 0.05f;

		public float MinAirborneTimeBeforeSecondJump = 0.05f;

		public bool AllowStandingStillActivation = true;

		public float MinimumHorizontalSpeedForActivation;

		public float MinimumMoveInputMagnitudeForActivation;

		public bool ResetNegativeVerticalVelocity = true;

		public bool ZeroVerticalVelocityBeforeJump;

		public bool PreserveCurrentHorizontalVelocity = true;

		public bool OverrideVerticalVelocity;

		public float VerticalVelocity;

		public float ForwardVelocity;

		public float DashDistance;

		public float DashLockDuration;

		public bool DashFlattenVerticalVelocity;

		public bool DashKeepConstantHeight;

		public float DashWallBuffer = 0.2f;

		public float DashMinimumUsableDistance = 0.75f;
	}
	public sealed class AirMobilityState
	{
		public bool WasGrounded = true;

		public bool SecondJumpUsed;

		public bool JumpReleasedAfterTakeoff;

		public bool WasJumpHeldLastFrame;

		public bool AirMobilityArmed;

		public float AirborneTime;

		public float DashLockUntil;

		public Vector3 DashDirection = Vector3.zero;

		public float DashSpeed;

		public bool DashFlattenVerticalVelocity;

		public bool DashKeepConstantHeight;

		public float DashFlatY;
	}
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	public static class AirMobilitySystem
	{
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		private static class DevLog
		{
			public const bool Enabled = false;

			public const bool Core = true;

			public const bool Movement = true;

			public const bool Resource = true;

			public const bool Verbose = false;
		}

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

		public static readonly List<AirMobilityDef> Defs = new List<AirMobilityDef>
		{
			new AirMobilityDef
			{
				DefName = "Windcaller",
				RequiredSEName = "SE_WindcallerArmor_DO",
				Mode = AirMobilityMode.VerticalBoost,
				DirectionMode = AirMobilityDirectionMode.LookDirection,
				StaminaCost = 15f,
				EitrCost = 0f,
				AdrenalineCost = 0f,
				JumpFxPrefabName = "fx_windcaller_jump_start_DO",
				AttachedFxPrefabName = "",
				RequireJumpRelease = true,
				MinAirborneTimeBeforeRelease = 0.05f,
				MinAirborneTimeBeforeSecondJump = 0.05f,
				AllowStandingStillActivation = true,
				MinimumHorizontalSpeedForActivation = 0f,
				MinimumMoveInputMagnitudeForActivation = 0f,
				ResetNegativeVerticalVelocity = true,
				ZeroVerticalVelocityBeforeJump = false,
				PreserveCurrentHorizontalVelocity = true,
				OverrideVerticalVelocity = true,
				VerticalVelocity = 14f,
				ForwardVelocity = 2.5f
			},
			new AirMobilityDef
			{
				DefName = "Stormcaller",
				RequiredSEName = "SE_StormcallerArmor_DO",
				Mode = AirMobilityMode.ForwardDashAir,
				DirectionMode = AirMobilityDirectionMode.CharacterForward,
				StaminaCost = 0f,
				EitrCost = 20f,
				AdrenalineCost = 0f,
				JumpFxPrefabName = "",
				AttachedFxPrefabName = "fx_stormcaller_jump_horizontal_attach_DO",
				RequireJumpRelease = true,
				MinAirborneTimeBeforeRelease = 0.05f,
				MinAirborneTimeBeforeSecondJump = 0.05f,
				AllowStandingStillActivation = false,
				MinimumHorizontalSpeedForActivation = 3.5f,
				MinimumMoveInputMagnitudeForActivation = 0.15f,
				ResetNegativeVerticalVelocity = true,
				ZeroVerticalVelocityBeforeJump = true,
				PreserveCurrentHorizontalVelocity = false,
				OverrideVerticalVelocity = false,
				VerticalVelocity = 0f,
				ForwardVelocity = 30f,
				DashDistance = 11f,
				DashLockDuration = 0.15f,
				DashFlattenVerticalVelocity = true,
				DashKeepConstantHeight = true,
				DashWallBuffer = 0.25f,
				DashMinimumUsableDistance = 1f
			}
		};

		private static readonly ConditionalWeakTable<Player, AirMobilityState> States = new ConditionalWeakTable<Player, AirMobilityState>();

		private static void Log(bool gate, string message)
		{
		}

		private static void LogThrottled(bool gate, string key, float intervalSeconds, string message)
		{
		}

		public static AirMobilityState GetState(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				LogThrottled(gate: false, "state.player_null", 2f, "GetState skipped => player is null");
				return null;
			}
			if (!States.TryGetValue(player, out var value))
			{
				value = new AirMobilityState
				{
					WasGrounded = ((Character)player).IsOnGround()
				};
				States.Add(player, value);
				Log(gate: true, $"State created | player='{SafePlayerName(player)}' | WasGrounded={value.WasGrounded}");
			}
			return value;
		}

		private static Rigidbody GetBody(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return null;
			}
			return Traverse.Create((object)player).Field("m_body").GetValue<Rigidbody>();
		}

		private static Vector3 GetMoveDir(Player player)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null)
			{
				return Vector3.zero;
			}
			return Traverse.Create((object)player).Field("m_moveDir").GetValue<Vector3>();
		}

		private static Transform GetEye(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return null;
			}
			return Traverse.Create((object)player).Field("m_eye").GetValue<Transform>();
		}

		private static float GetHorizontalSpeed(Player player)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			Rigidbody body = GetBody(player);
			if ((Object)(object)body == (Object)null)
			{
				return 0f;
			}
			Vector3 linearVelocity = body.linearVelocity;
			linearVelocity.y = 0f;
			return ((Vector3)(ref linearVelocity)).magnitude;
		}

		private static float GetMoveInputMagnitude(Player player)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			Vector3 moveDir = GetMoveDir(player);
			moveDir.y = 0f;
			return ((Vector3)(ref moveDir)).magnitude;
		}

		public static AirMobilityDef GetActiveDef(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return null;
			}
			foreach (AirMobilityDef def in Defs)
			{
				if (def != null && !string.IsNullOrWhiteSpace(def.RequiredSEName) && HasRequiredSE(player, def.RequiredSEName))
				{
					return def;
				}
			}
			return null;
		}

		private static bool HasRequiredSE(Player player, string seName)
		{
			if ((Object)(object)player == (Object)null || string.IsNullOrWhiteSpace(seName))
			{
				return false;
			}
			SEMan sEMan = ((Character)player).GetSEMan();
			if (sEMan == null)
			{
				return false;
			}
			int stableHashCode = StringExtensionMethods.GetStableHashCode(seName);
			return sEMan.HaveStatusEffect(stableHashCode);
		}

		private static bool HaveResources(Player player, AirMobilityDef def)
		{
			bool flag = def.StaminaCost <= 0f || ((Character)player).HaveStamina(def.StaminaCost);
			bool flag2 = def.EitrCost <= 0f || ((Character)player).HaveEitr(def.EitrCost);
			bool flag3 = def.AdrenalineCost <= 0f || player.GetAdrenaline() >= def.AdrenalineCost;
			bool flag4 = flag && flag2 && flag3;
			Log(gate: true, "HaveResources | player='" + SafePlayerName(player) + "' | def='" + def.DefName + "' | " + $"staminaNeed={def.StaminaCost:0.##} ok={flag} current={player.GetStamina():0.##} | " + $"eitrNeed={def.EitrCost:0.##} ok={flag2} current={player.GetEitr():0.##} | " + $"adrenalineNeed={def.AdrenalineCost:0.##} ok={flag3} current={player.GetAdrenaline():0.##} | " + $"result={flag4}");
			return flag4;
		}

		private static void ConsumeResources(Player player, AirMobilityDef def)
		{
			if (def.StaminaCost > 0f)
			{
				((Character)player).UseStamina(def.StaminaCost);
			}
			if (def.EitrCost > 0f)
			{
				((Character)player).UseEitr(def.EitrCost);
			}
			if (def.AdrenalineCost > 0f)
			{
				((Character)player).AddAdrenaline(0f - def.AdrenalineCost);
			}
			Log(gate: true, "ConsumeResources | player='" + SafePlayerName(player) + "' | def='" + def.DefName + "' | " + $"stamina-={def.StaminaCost:0.##} | eitr-={def.EitrCost:0.##} | adrenaline-={def.AdrenalineCost:0.##}");
		}

		private static void FlashEmptyResources(Player player, AirMobilityDef def)
		{
			if (!((Object)(object)Hud.instance == (Object)null) && def.StaminaCost > 0f && !((Character)player).HaveStamina(def.StaminaCost))
			{
				Hud.instance.StaminaBarEmptyFlash();
			}
		}

		public static void UpdateGroundedState(Player player)
		{
			if (!((Object)(object)player == (Object)null) && IsLocalOwner(player))
			{
				AirMobilityState state = GetState(player);
				bool flag = ((Character)player).IsOnGround();
				if (!flag)
				{
					state.AirborneTime += Time.fixedDeltaTime;
				}
				if (flag && !state.WasGrounded)
				{
					state.SecondJumpUsed = false;
					state.JumpReleasedAfterTakeoff = false;
					state.AirMobilityArmed = false;
					state.AirborneTime = 0f;
					ClearDashLock(state);
					Log(gate: true, "Landing reset | player='" + SafePlayerName(player) + "' | SecondJumpUsed=false | JumpReleasedAfterTakeoff=false | AirMobilityArmed=false | DashLock cleared");
				}
				if (!flag && state.WasGrounded)
				{
					state.SecondJumpUsed = false;
					state.JumpReleasedAfterTakeoff = false;
					state.AirMobilityArmed = true;
					state.AirborneTime = 0f;
					Log(gate: true, "Takeoff detected | player='" + SafePlayerName(player) + "' | airborne cycle started | AirMobilityArmed=true");
				}
				state.WasGrounded = flag;
			}
		}

		public static void UpdateJumpHoldState(Player player, bool jumpHeld)
		{
			if (!((Object)(object)player == (Object)null) && IsLocalOwner(player))
			{
				AirMobilityState state = GetState(player);
				AirMobilityDef activeDef = GetActiveDef(player);
				float num = 0.05f;
				if (activeDef != null)
				{
					num = Mathf.Max(0f, activeDef.MinAirborneTimeBeforeRelease);
				}
				if (!((Character)player).IsOnGround() && state.AirMobilityArmed && state.AirborneTime >= num && !jumpHeld && !state.JumpReleasedAfterTakeoff)
				{
					state.JumpReleasedAfterTakeoff = true;
					Log(gate: true, $"Jump release registered in air | player='{SafePlayerName(player)}' | airborneTime={state.AirborneTime:0.###}");
				}
				state.WasJumpHeldLastFrame = jumpHeld;
			}
		}

		public static void UpdateDashLock(Player player)
		{
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null || !IsLocalOwner(player))
			{
				return;
			}
			AirMobilityState state = GetState(player);
			if (state == null || state.DashLockUntil <= 0f)
			{
				return;
			}
			if (Time.time >= state.DashLockUntil)
			{
				ClearDashLock(state);
				Log(gate: true, "Dash lock expired | player='" + SafePlayerName(player) + "'");
				return;
			}
			if (((Character)player).IsOnGround() || ((Character)player).IsDead() || ((Character)player).IsTeleporting() || ((Character)player).IsSwimming() || ((Character)player).IsAttached())
			{
				ClearDashLock(state);
				Log(gate: true, $"Dash lock interrupted | player='{SafePlayerName(player)}' | onGround={((Character)player).IsOnGround()} dead={((Character)player).IsDead()} teleporting={((Character)player).IsTeleporting()} swimming={((Character)player).IsSwimming()} attached={((Character)player).IsAttached()}");
				return;
			}
			Rigidbody body = GetBody(player);
			if (!((Object)(object)body == (Object)null))
			{
				Vector3 linearVelocity = body.linearVelocity;
				linearVelocity.x = state.DashDirection.x * state.DashSpeed;
				linearVelocity.z = state.DashDirection.z * state.DashSpeed;
				if (state.DashFlattenVerticalVelocity)
				{
					linearVelocity.y = 0f;
				}
				body.linearVelocity = linearVelocity;
				if (state.DashKeepConstantHeight)
				{
					Vector3 position = ((Component)player).transform.position;
					position.y = state.DashFlatY;
					((Component)player).transform.position = position;
				}
			}
		}

		private static void SetupDashLock(Player player, AirMobilityDef def, Vector3 direction, float actualDashDistance, Vector3 resultingVelocity)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null || def == null || def.DashLockDuration <= 0f)
			{
				return;
			}
			AirMobilityState state = GetState(player);
			if (state != null)
			{
				Vector3 dashDirection = direction;
				dashDirection.y = 0f;
				if (((Vector3)(ref dashDirection)).sqrMagnitude > 0.0001f)
				{
					((Vector3)(ref dashDirection)).Normalize();
				}
				float dashSpeed;
				if (actualDashDistance > 0f && def.DashLockDuration > 0f)
				{
					dashSpeed = actualDashDistance / def.DashLockDuration;
				}
				else
				{
					Vector3 val = new Vector3(resultingVelocity.x, 0f, resultingVelocity.z);
					dashSpeed = ((Vector3)(ref val)).magnitude;
				}
				state.DashLockUntil = Time.time + def.DashLockDuration;
				state.DashDirection = dashDirection;
				state.DashSpeed = dashSpeed;
				state.DashFlattenVerticalVelocity = def.DashFlattenVerticalVelocity;
				state.DashKeepConstantHeight = def.DashKeepConstantHeight;
				state.DashFlatY = ((Component)player).transform.position.y;
				Log(gate: true, $"Dash lock setup | player='{SafePlayerName(player)}' | def='{def.DefName}' | duration={def.DashLockDuration:0.###} | safeDistance={actualDashDistance:0.##} | direction={state.DashDirection} | speed={state.DashSpeed:0.##} | flatY={state.DashFlatY:0.##} | flattenY={state.DashFlattenVerticalVelocity} | keepHeight={state.DashKeepConstantHeight}");
			}
		}

		private static void ClearDashLock(AirMobilityState state)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (state != null)
			{
				state.DashLockUntil = 0f;
				state.DashDirection = Vector3.zero;
				state.DashSpeed = 0f;
				state.DashFlattenVerticalVelocity = false;
				state.DashKeepConstantHeight = false;
				state.DashFlatY = 0f;
			}
		}

		public static bool TryUseAirMobility(Player player, bool jumpPressedThisFrame)
		{
			if ((Object)(object)player == (Object)null || !IsLocalOwner(player) || !jumpPressedThisFrame)
			{
				return false;
			}
			AirMobilityDef activeDef = GetActiveDef(player);
			if (activeDef == null)
			{
				return false;
			}
			AirMobilityState state = GetState(player);
			if (!CanUseAirMobility(player, activeDef, state, out var reason))
			{
				Log(gate: true, "Second jump denied | player='" + SafePlayerName(player) + "' | def='" + activeDef.DefName + "' | reason=" + reason);
				return false;
			}
			if (!HaveResources(player, activeDef))
			{
				FlashEmptyResources(player, activeDef);
				Log(gate: true, "Second jump denied | player='" + SafePlayerName(player) + "' | def='" + activeDef.DefName + "' | reason=NotEnoughResources");
				return false;
			}
			ConsumeResources(player, activeDef);
			bool flag = false;
			switch (activeDef.Mode)
			{
			case AirMobilityMode.VerticalBoost:
				ApplyVerticalBoost(player, activeDef);
				SpawnFx(player, activeDef.JumpFxPrefabName);
				SpawnAttachedFx(player, activeDef.AttachedFxPrefabName);
				flag = true;
				break;
			case AirMobilityMode.ForwardDashAir:
				flag = ApplyForwardDashAir(player, activeDef);
				break;
			}
			if (flag)
			{
				state.SecondJumpUsed = true;
				Log(gate: true, $"Second jump SUCCESS | player='{SafePlayerName(player)}' | def='{activeDef.DefName}' | mode={activeDef.Mode}");
			}
			return flag;
		}

		private static bool CanUseAirMobility(Player player, AirMobilityDef def, AirMobilityState state, out string reason)
		{
			reason = "Unknown";
			if ((Object)(object)player == (Object)null)
			{
				reason = "PlayerNull";
				return false;
			}
			if (def == null)
			{
				reason = "DefNull";
				return false;
			}
			if (state == null)
			{
				reason = "StateNull";
				return false;
			}
			if (((Character)player).IsDead())
			{
				reason = "IsDead";
				return false;
			}
			if (((Character)player).IsTeleporting())
			{
				reason = "IsTeleporting";
				return false;
			}
			if (((Character)player).IsSwimming())
			{
				reason = "IsSwimming";
				return false;
			}
			if (((Character)player).IsAttached())
			{
				reason = "IsAttached";
				return false;
			}
			if (((Character)player).InBed())
			{
				reason = "InBed";
				return false;
			}
			if (((Character)player).InCutscene())
			{
				reason = "InCutscene";
				return false;
			}
			if (((Character)player).InEmote())
			{
				reason = "InEmote";
				return false;
			}
			if (((Character)player).InDodge())
			{
				reason = "InDodge";
				return false;
			}
			if (((Character)player).IsKnockedBack())
			{
				reason = "IsKnockedBack";
				return false;
			}
			if (((Character)player).IsStaggering())
			{
				reason = "IsStaggering";
				return false;
			}
			if (((Character)player).IsEncumbered())
			{
				reason = "IsEncumbered";
				return false;
			}
			if (!((Character)player).CanMove())
			{
				reason = "CanMoveFalse";
				return false;
			}
			if (((Character)player).IsOnGround())
			{
				reason = "IsOnGround";
				return false;
			}
			if (!state.AirMobilityArmed)
			{
				reason = "AirMobilityNotArmed";
				return false;
			}
			if (state.SecondJumpUsed)
			{
				reason = "SecondJumpAlreadyUsed";
				return false;
			}
			if (state.AirborneTime < Mathf.Max(0f, def.MinAirborneTimeBeforeSecondJump))
			{
				reason = "AirborneTooShort";
				return false;
			}
			if (def.RequireJumpRelease && !state.JumpReleasedAfterTakeoff)
			{
				reason = "JumpNotReleasedAfterTakeoff";
				return false;
			}
			float horizontalSpeed = GetHorizontalSpeed(player);
			float moveInputMagnitude = GetMoveInputMagnitude(player);
			if (!def.AllowStandingStillActivation && horizontalSpeed < def.MinimumHorizontalSpeedForActivation)
			{
				reason = "BelowMinimumHorizontalSpeed";
				return false;
			}
			if (def.MinimumHorizontalSpeedForActivation > 0f && horizontalSpeed < def.MinimumHorizontalSpeedForActivation)
			{
				reason = "BelowMinimumHorizontalSpeed";
				return false;
			}
			if (def.MinimumMoveInputMagnitudeForActivation > 0f && moveInputMagnitude < def.MinimumMoveInputMagnitudeForActivation)
			{
				reason = "BelowMinimumMoveInput";
				return false;
			}
			reason = "Allowed";
			return true;
		}

		private static void ApplyVerticalBoost(Player player, AirMobilityDef def)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			Rigidbody body = GetBody(player);
			if ((Object)(object)body == (Object)null)
			{
				LogThrottled(gate: false, "movement.vertical.body_null." + SafePlayerName(player), 2f, "ApplyVerticalBoost aborted => body null | player='" + SafePlayerName(player) + "' | def='" + def.DefName + "'");
				return;
			}
			Vector3 linearVelocity = body.linearVelocity;
			Vector3 val = linearVelocity;
			if (def.OverrideVerticalVelocity)
			{
				val.y = def.VerticalVelocity;
			}
			else
			{
				if (def.ZeroVerticalVelocityBeforeJump)
				{
					val.y = 0f;
				}
				else if (def.ResetNegativeVerticalVelocity && val.y < 0f)
				{
					val.y = 0f;
				}
				val.y += def.VerticalVelocity;
			}
			Vector3 desiredPlanarDirection = GetDesiredPlanarDirection(player, def);
			if (((Vector3)(ref desiredPlanarDirection)).sqrMagnitude > 0.0001f && Mathf.Abs(def.ForwardVelocity) > 0.001f)
			{
				if (def.PreserveCurrentHorizontalVelocity)
				{
					val += desiredPlanarDirection * def.ForwardVelocity;
				}
				else
				{
					val.x = desiredPlanarDirection.x * def.ForwardVelocity;
					val.z = desiredPlanarDirection.z * def.ForwardVelocity;
				}
			}
			body.linearVelocity = val;
			Log(gate: true, $"ApplyVerticalBoost | player='{SafePlayerName(player)}' | def='{def.DefName}' | before={linearVelocity} | after={val} | vertical={def.VerticalVelocity:0.##} | forward={def.ForwardVelocity:0.##} | overrideVertical={def.OverrideVerticalVelocity}");
		}

		private static bool ApplyForwardDashAir(Player player, AirMobilityDef def)
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			Rigidbody body = GetBody(player);
			if ((Object)(object)body == (Object)null)
			{
				LogThrottled(gate: false, "movement.dash.body_null." + SafePlayerName(player), 2f, "ApplyForwardDashAir aborted => body null | player='" + SafePlayerName(player) + "' | def='" + def.DefName + "'");
				return false;
			}
			Vector3 val = GetDesiredPlanarDirection(player, def);
			if (((Vector3)(ref val)).sqrMagnitude < 0.0001f)
			{
				val = ((Component)player).transform.forward;
				val.y = 0f;
				((Vector3)(ref val)).Normalize();
			}
			float num = Mathf.Max(0f, def.DashDistance);
			float safeDashDistance = GetSafeDashDistance(player, val, num, def.DashWallBuffer);
			if (safeDashDistance < def.DashMinimumUsableDistance)
			{
				Log(gate: true, $"Dash denied by wall proximity | player='{SafePlayerName(player)}' | def='{def.DefName}' | desiredDistance={num:0.##} | safeDistance={safeDashDistance:0.##} | minUsable={def.DashMinimumUsableDistance:0.##}");
				return false;
			}
			Vector3 linearVelocity = body.linearVelocity;
			Vector3 val2 = linearVelocity;
			if (def.ZeroVerticalVelocityBeforeJump)
			{
				val2.y = 0f;
			}
			else if (def.ResetNegativeVerticalVelocity && val2.y < 0f)
			{
				val2.y = 0f;
			}
			float num2 = def.ForwardVelocity;
			if (safeDashDistance > 0f && def.DashLockDuration > 0f)
			{
				num2 = safeDashDistance / def.DashLockDuration;
			}
			Vector3 val3 = val * num2;
			if (def.PreserveCurrentHorizontalVelocity)
			{
				val2.x += val3.x;
				val2.z += val3.z;
			}
			else
			{
				val2.x = val3.x;
				val2.z = val3.z;
			}
			val2.y += def.VerticalVelocity;
			body.linearVelocity = val2;
			SetupDashLock(player, def, val, safeDashDistance, val2);
			SpawnFx(player, def.JumpFxPrefabName);
			SpawnAttachedFx(player, def.AttachedFxPrefabName);
			Log(gate: true, $"ApplyForwardDashAir | player='{SafePlayerName(player)}' | def='{def.DefName}' | dir={val} | before={linearVelocity} | after={val2} | desiredDistance={num:0.##} | safeDistance={safeDashDistance:0.##} | horizontalSpeed={num2:0.##}");
			return true;
		}

		private static Vector3 GetDesiredPlanarDirection(Player player, AirMobilityDef def)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null)
			{
				return Vector3.zero;
			}
			Vector3 result = Vector3.zero;
			switch (def.DirectionMode)
			{
			case AirMobilityDirectionMode.LookDirection:
			{
				Transform eye = GetEye(player);
				result = (((Object)(object)eye != (Object)null) ? eye.forward : ((Component)player).transform.forward);
				break;
			}
			case AirMobilityDirectionMode.MoveDirection:
				result = GetMoveDir(player);
				if (((Vector3)(ref result)).sqrMagnitude < 0.0001f)
				{
					result = ((Component)player).transform.forward;
				}
				break;
			default:
				result = ((Component)player).transform.forward;
				break;
			}
			result.y = 0f;
			if (((Vector3)(ref result)).sqrMagnitude > 0.0001f)
			{
				((Vector3)(ref result)).Normalize();
			}
			return result;
		}

		private static float GetSafeDashDistance(Player player, Vector3 direction, float desiredDistance, float wallBuffer)
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null || desiredDistance <= 0f)
			{
				return 0f;
			}
			CapsuleCollider collider = ((Character)player).GetCollider();
			if ((Object)(object)collider == (Object)null)
			{
				LogThrottled(gate: false, "dash.safe.no_capsule." + SafePlayerName(player), 2f, $"GetSafeDashDistance => no capsule | player='{SafePlayerName(player)}' | fallbackDistance={desiredDistance:0.##}");
				return desiredDistance;
			}
			Transform transform = ((Component)player).transform;
			float num = collider.radius * Mathf.Max(transform.lossyScale.x, transform.lossyScale.z) * 0.95f;
			float num2 = Mathf.Max(collider.height * transform.lossyScale.y, num * 2f);
			Vector3 val = transform.position + transform.rotation * Vector3.Scale(collider.center, transform.lossyScale);
			Vector3 val2 = Vector3.up * (num2 * 0.5f - num);
			Vector3 val3 = val + val2;
			Vector3 val4 = val - val2;
			int mask = LayerMask.GetMask(new string[7] { "Default", "static_solid", "Default_small", "piece", "piece_nonsolid", "terrain", "vehicle" });
			RaycastHit val5 = default(RaycastHit);
			if (Physics.CapsuleCast(val3, val4, num, direction, ref val5, desiredDistance, mask, (QueryTriggerInteraction)1))
			{
				float num3 = Mathf.Max(0f, ((RaycastHit)(ref val5)).distance - Mathf.Max(0f, wallBuffer));
				Log(gate: true, $"Dash collision probe hit | player='{SafePlayerName(player)}' | hit='{((Object)((RaycastHit)(ref val5)).collider).name}' | rawHitDistance={((RaycastHit)(ref val5)).distance:0.##} | safeDistance={num3:0.##} | desiredDistance={desiredDistance:0.##}");
				return num3;
			}
			return desiredDistance;
		}

		private static void SpawnFx(Player player, string prefabName)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)player == (Object)null))
			{
				SpawnFxAtPosition(prefabName, ((Component)player).transform.position, ((Component)player).transform.rotation);
			}
		}

		private static void SpawnAttachedFx(Player player, string prefabName)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)player == (Object)null) && !string.IsNullOrWhiteSpace(prefabName))
			{
				GameObject fxPrefab = GetFxPrefab(prefabName);
				if ((Object)(object)fxPrefab == (Object)null)
				{
					LogThrottled(gate: false, "fx.attached.not_found." + prefabName, 2f, "Attached FX prefab not found: " + prefabName);
					return;
				}
				GameObject obj = Object.Instantiate<GameObject>(fxPrefab, ((Component)player).transform.position, ((Component)player).transform.rotation);
				obj.transform.SetParent(((Component)player).transform, false);
				obj.transform.localPosition = Vector3.zero;
				obj.transform.localRotation = Quaternion.identity;
				Log(gate: true, "Attached FX spawned | prefab='" + prefabName + "' | player='" + SafePlayerName(player) + "'");
			}
		}

		private static void SpawnFxAtPosition(string prefabName, Vector3 position, Quaternion rotation)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			if (!string.IsNullOrWhiteSpace(prefabName))
			{
				GameObject fxPrefab = GetFxPrefab(prefabName);
				if ((Object)(object)fxPrefab == (Object)null)
				{
					LogThrottled(gate: false, "fx.not_found." + prefabName, 2f, "FX prefab not found: " + prefabName);
				}
				else
				{
					Object.Instantiate<GameObject>(fxPrefab, position, rotation);
				}
			}
		}

		private static GameObject GetFxPrefab(string prefabName)
		{
			if (string.IsNullOrWhiteSpace(prefabName))
			{
				return null;
			}
			if ((Object)(object)ZNetScene.instance != (Object)null)
			{
				GameObject prefab = ZNetScene.instance.GetPrefab(prefabName);
				if ((Object)(object)prefab != (Object)null)
				{
					return prefab;
				}
			}
			if ((Object)(object)ObjectDB.instance != (Object)null)
			{
				GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(prefabName);
				if ((Object)(object)itemPrefab != (Object)null)
				{
					return itemPrefab;
				}
			}
			return null;
		}

		private static bool IsLocalOwner(Player player)
		{
			if ((Object)(object)player == (Object)null || (Object)(object)((Character)player).m_nview == (Object)null || !((Character)player).m_nview.IsValid())
			{
				return false;
			}
			return ((Character)player).m_nview.IsOwner();
		}

		private static string SafePlayerName(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return "null";
			}
			try
			{
				string playerName = player.GetPlayerName();
				return string.IsNullOrEmpty(playerName) ? "unknown" : playerName;
			}
			catch
			{
				return "unknown";
			}
		}
	}
	[HarmonyPatch(typeof(Player), "SetControls")]
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	public static class AirMobilitySystem_Player_SetControls_Patch
	{
		private static void Prefix(Player __instance, ref bool __state)
		{
			__state = (Object)(object)__instance != (Object)null && ((Character)__instance).IsOnGround();
		}

		private static void Postfix(Player __instance, bool jump, bool __state)
		{
			if ((Object)(object)__instance == (Object)null || (Object)(object)((Character)__instance).m_nview == (Object)null || !((Character)__instance).m_nview.IsValid() || !((Character)__instance).m_nview.IsOwner())
			{
				return;
			}
			AirMobilityState state = AirMobilitySystem.GetState(__instance);
			if (state != null)
			{
				if (jump && !state.WasJumpHeldLastFrame && !__state && !((Character)__instance).IsOnGround())
				{
					AirMobilitySystem.TryUseAirMobility(__instance, jumpPressedThisFrame: true);
				}
				AirMobilitySystem.UpdateJumpHoldState(__instance, jump);
			}
		}
	}
	[HarmonyPatch(typeof(Player), "FixedUpdate")]
	public static class AirMobilitySystem_Player_FixedUpdate_Patch
	{
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
		private static void Postfix(Player __instance)
		{
			if (!((Object)(object)__instance == (Object)null) && !((Object)(object)((Character)__instance).m_nview == (Object)null) && ((Character)__instance).m_nview.IsValid() && ((Character)__instance).m_nview.IsOwner())
			{
				AirMobilitySystem.UpdateGroundedState(__instance);
				AirMobilitySystem.UpdateDashLock(__instance);
			}
		}
	}
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	public static class AoeOutwardLaunchPatch
	{
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		private static class DevLog
		{
			public const bool Enabled = false;
		}

		[HarmonyPatch(typeof(Aoe), "OnHit")]
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		private static class Aoe_OnHit_OutwardLaunchPatch
		{
			[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				MethodInfo replacementMethod = AccessTools.Method(typeof(AoeOutwardLaunchPatch), "GetLaunchDirection", (Type[])null, (Type[])null);
				bool patched = false;
				foreach (CodeInstruction instruction in instructions)
				{
					if (!patched && IsDirToCall(instruction))
					{
						yield return new CodeInstruction(OpCodes.Ldarg_0, (object)null);
						yield return new CodeInstruction(OpCodes.Call, (object)replacementMethod);
						patched = true;
						Log("Patched Aoe.OnHit launch direction.");
					}
					else
					{
						yield return instruction;
					}
				}
				if (!patched)
				{
					Log("WARNING: Could not find DirTo call inside Aoe.OnHit.");
				}
			}
		}

		private static readonly HashSet<string> OutwardLaunchAoes = new HashSet<string> { "aoe_totemcaller_shield_break_DO" };

		private static void Log(string msg)
		{
		}

		private static bool IsDirToCall(CodeInstruction instruction)
		{
			if (instruction.opcode != OpCodes.Call && instruction.opcode != OpCodes.Callvirt)
			{
				return false;
			}
			if (!(instruction.operand is MethodInfo methodInfo))
			{
				return false;
			}
			if (methodInfo.Name != "DirTo")
			{
				return false;
			}
			if (methodInfo.ReturnType != typeof(Vector3))
			{
				return false;
			}
			ParameterInfo[] parameters = methodInfo.GetParameters();
			if (parameters.Length == 2 && parameters[0].ParameterType == typeof(Vector3))
			{
				return parameters[1].ParameterType == typeof(Vector3);
			}
			return false;
		}

		private static Vector3 GetLaunchDirection(Vector3 from, Vector3 to, Aoe aoe)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = to - from;
			Vector3 normalized = ((Vector3)(ref val)).normalized;
			if ((Object)(object)aoe == (Object)null)
			{
				return normalized;
			}
			if (!aoe.m_launchCharacters)
			{
				return normalized;
			}
			string prefabName = Utils.GetPrefabName(((Object)aoe).name);
			if (!OutwardLaunchAoes.Contains(prefabName))
			{
				return normalized;
			}
			val = from - to;
			Vector3 normalized2 = ((Vector3)(ref val)).normalized;
			Log("Inverted launch direction for " + prefabName);
			return normalized2;
		}
	}
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	public static class ConfigVersionManager
	{
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		[HarmonyPatch(typeof(FejdStartup), "Update")]
		private static class FejdStartup_Update_Patch
		{
			private static void Postfix()
			{
				TryShowPrompt();
			}
		}

		private const bool EnableLogs = false;

		private const string InternalFolderRelativePath = "DistantOrigins/Internal";

		private const string SectionVersion = "Version";

		private const string KeyLastHandledVersion = "LastHandledVersion";

		private const string KeyLastDecision = "LastDecision";

		private const string DecisionResetToDefaults = "ResetToDefaults";

		private const string DecisionKeepCurrentSettings = "KeepCurrentSettings";

		private const string PromptTitleKey = "$config_update_title_DO";

		private const string PromptLine1Key = "$config_update_line_1_DO";

		private const string PromptLine2Key = "$config_update_line_2_DO";

		private const string PromptLine3Key = "$config_update_line_3_DO";

		private const string PromptLine4Key = "$config_update_line_4_DO";

		private const string PromptLine5Key = "$config_update_line_5_DO";

		private const string PromptTitleFallback = "{0} Updated";

		private const string PromptLine1Fallback = "{0} has been updated to version {1}.";

		private const string PromptLine2Fallback = "This update includes new config values.";

		private const string PromptLine3Fallback = "Reset the configs to the new default values?";

		private const string PromptLine4Fallback = "- YES - apply the recommended defaults.";

		private const string PromptLine5Fallback = "- NO - keep your current settings.";

		private const float HeaderFontSize = 26f;

		private const float BodyFontSizeMax = 17.8f;

		private const float BodyFontSizeMin = 9f;

		private const float ButtonFontSizeMax = 18f;

		private const float ButtonFontSizeMin = 10f;

		private const string HeaderColor = "#FFC654";

		private const string BodyLine1Color = "#DADADA";

		private const string BodyLine2Color = "#D2D2D2";

		private const string BodyLine3Color = "#FFC654";

		private const string BodyLine4Color = "#E6E6E6";

		private const string BodyLine5Color = "#E6E6E6";

		private const string ButtonColor = "#FFC654";

		private static string _modName;

		private static string _modDisplayName;

		private static string _modVersion;

		private static ConfigFile _mainConfig;

		private static ConfigFile _internalConfig;

		private static ConfigEntry<string> _lastHandledVersion;

		private static ConfigEntry<string> _lastDecision;

		private static Action _onResetApplied;

		private static bool _initialized;

		private static bool _promptOpen;

		public static bool IsInitialized => _initialized;

		public static string CurrentModVersion => _modVersion;

		public static string LastHandledVersion
		{
			get
			{
				if (_lastHandledVersion == null)
				{
					return string.Empty;
				}
				return _lastHandledVersion.Value;
			}
		}

		public static string LastDecision
		{
			get
			{
				if (_lastDecision == null)
				{
					return string.Empty;
				}
				return _lastDecision.Value;
			}
		}

		private static void Log(string message)
		{
		}

		public static void Initialize(string modName, string modVersion, ConfigFile mainConfig, Action onResetApplied = null)
		{
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			if (_initialized)
			{
				Log("Already initialized. Skipping.");
				return;
			}
			if (string.IsNullOrWhiteSpace(modName))
			{
				throw new ArgumentException("Mod name cannot be empty.", "modName");
			}
			if (string.IsNullOrWhiteSpace(modVersion))
			{
				throw new ArgumentException("Mod version cannot be empty.", "modVersion");
			}
			if (mainConfig == null)
			{
				throw new ArgumentNullException("mainConfig");
			}
			_modName = modName;
			_modDisplayName = GetDisplayModName(modName);
			_modVersion = modVersion;
			_mainConfig = mainConfig;
			_onResetApplied = onResetApplied;
			string text = Path.Combine(Paths.ConfigPath, "DistantOrigins/Internal");
			Directory.CreateDirectory(text);
			_internalConfig = new ConfigFile(Path.Combine(text, _modName + "_Internal.cfg"), true);
			_lastHandledVersion = _internalConfig.Bind<string>("Version", "LastHandledVersion", "", "Last mod version where the configuration update prompt was handled.");
			_lastDecision = _internalConfig.Bind<string>("Version", "LastDecision", "", "Last configuration update decision. Possible values: ResetToDefaults, KeepCurrentSettings.");
			_internalConfig.Save();
			_initialized = true;
			Log("Initialized. ModVersion=" + _modVersion + ", LastHandledVersion=" + _lastHandledVersion.Value);
		}

		private static string GetDisplayModName(string modName)
		{
			if (!string.IsNullOrWhiteSpace(modName))
			{
				return modName.Replace("_", " ");
			}
			return "";
		}

		public static bool ShouldShowPrompt()
		{
			EnsureInitialized();
			return !string.Equals(_lastHandledVersion.Value, _modVersion, StringComparison.OrdinalIgnoreCase);
		}

		public static void TryShowPrompt()
		{
			if (_initialized && !_promptOpen && ShouldShowPrompt() && UnifiedPopup.IsAvailable() && !UnifiedPopup.IsVisible())
			{
				ShowPrompt();
			}
		}

		private static void ShowPrompt()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			//IL_003f: Expected O, but got Unknown
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			EnsureInitialized();
			_promptOpen = true;
			string text = BuildPromptTitle();
			string text2 = BuildPromptBody();
			Log("Showing config update prompt.");
			UnifiedPopup.Push((PopupBase)new YesNoPopup(text, text2, new PopupButtonCallback(OnResetSelected), new PopupButtonCallback(OnKeepSelected), false));
			ApplyPopupVisualStyle();
		}

		private static string BuildPromptTitle()
		{
			return SafeFormat(LocalizeOrFallback("$config_update_title_DO", "{0} Updated"), _modDisplayName);
		}

		private static string BuildPromptBody()
		{
			string template = LocalizeOrFallback("$config_update_line_1_DO", "{0} has been updated to version {1}.");
			string template2 = LocalizeOrFallback("$config_update_line_2_DO", "This update includes new config values.");
			string template3 = LocalizeOrFallback("$config_update_line_3_DO", "Reset the configs to the new default values?");
			string template4 = LocalizeOrFallback("$config_update_line_4_DO", "- YES - apply the recommended defaults.");
			string template5 = LocalizeOrFallback("$config_update_line_5_DO", "- NO - keep your current settings.");
			string text = SafeFormat(template, _modDisplayName, _modVersion);
			string text2 = SafeFormat(template2, _modDisplayName, _modVersion);
			string text3 = SafeFormat(template3, _modDisplayName, _modVersion);
			string text4 = SafeFormat(template4, _modDisplayName, _modVersion);
			string text5 = SafeFormat(template5, _modDisplayName, _modVersion);
			return "<color=#DADADA>" + text + "</color>\n<color=#D2D2D2>" + text2 + "</color>\n\n<color=#FFC654>" + text3 + "</color>\n<color=#E6E6E6>" + text4 + "</color>\n<color=#E6E6E6>" + text5 + "</color>";
		}

		private static string BuildYesButtonText()
		{
			string text = ((Localization.instance != null) ? Localization.instance.Localize("$menu_yes") : "YES");
			return "<color=#FFC654>" + text + "</color>";
		}

		private static string BuildNoButtonText()
		{
			string text = ((Localization.instance != null) ? Localization.instance.Localize("$menu_no") : "NO");
			return "<color=#FFC654>" + text + "</color>";
		}

		private static string LocalizeOrFallback(string key, string fallback)
		{
			try
			{
				if (Localization.instance == null)
				{
					return fallback;
				}
				string text = Localization.instance.Localize(key);
				if (string.IsNullOrWhiteSpace(text))
				{
					return fallback;
				}
				if (text == key)
				{
					return fallback;
				}
				return text;
			}
			catch
			{
				return fallback;
			}
		}

		private static string SafeFormat(string template, params object[] args)
		{
			try
			{
				return string.Format(template, args);
			}
			catch
			{
				return template;
			}
		}

		private static void ApplyPopupVisualStyle()
		{
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Expected O, but got Unknown
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Expected O, but got Unknown
			try
			{
				object obj = AccessTools.Field(typeof(UnifiedPopup), "instance")?.GetValue(null);
				if (obj == null)
				{
					Log("UnifiedPopup instance not found. Visual style was not applied.");
					return;
				}
				object? obj2 = AccessTools.Field(typeof(UnifiedPopup), "buttonLeft")?.GetValue(obj);
				Button val = (Button)((obj2 is Button) ? obj2 : null);
				object? obj3 = AccessTools.Field(typeof(UnifiedPopup), "buttonRight")?.GetValue(obj);
				Button val2 = (Button)((obj3 is Button) ? obj3 : null);
				object? obj4 = AccessTools.Field(typeof(UnifiedPopup), "headerText")?.GetValue(obj);
				TextMeshProUGUI val3 = (TextMeshProUGUI)((obj4 is TextMeshProUGUI) ? obj4 : null);
				object? obj5 = AccessTools.Field(typeof(UnifiedPopup), "bodyText")?.GetValue(obj);
				TextMeshProUGUI val4 = (TextMeshProUGUI)((obj5 is TextMeshProUGUI) ? obj5 : null);
				object? obj6 = AccessTools.Field(typeof(UnifiedPopup), "buttonLeftText")?.GetValue(obj);
				TMP_Text val5 = (TMP_Text)((obj6 is TMP_Text) ? obj6 : null);
				object? obj7 = AccessTools.Field(typeof(UnifiedPopup), "buttonRightText")?.GetValue(obj);
				TMP_Text val6 = (TMP_Text)((obj7 is TMP_Text) ? obj7 : null);
				if ((Object)(object)val3 != (Object)null)
				{
					((TMP_Text)val3).enableAutoSizing = false;
					((TMP_Text)val3).fontSize = 26f;
					((TMP_Text)val3).richText = true;
					((TMP_Text)val3).text = "<color=#FFC654>" + BuildPromptTitle() + "</color>";
				}
				if ((Object)(object)val4 != (Object)null)
				{
					((TMP_Text)val4).enableAutoSizing = true;
					((TMP_Text)val4).fontSizeMin = 9f;
					((TMP_Text)val4).fontSizeMax = 17.8f;
					((TMP_Text)val4).richText = true;
					((TMP_Text)val4).text = BuildPromptBody();
				}
				if ((Object)(object)val != (Object)null)
				{
					((UnityEventBase)val.onClick).RemoveAllListeners();
					((UnityEvent)val.onClick).AddListener(new UnityAction(OnResetSelected));
					((Component)val).gameObject.SetActive(true);
				}
				if ((Object)(object)val2 != (Object)null)
				{
					((UnityEventBase)val2.onClick).RemoveAllListeners();
					((UnityEvent)val2.onClick).AddListener(new UnityAction(OnKeepSelected));
					((Component)val2).gameObject.SetActive(true);
				}
				if ((Object)(object)val5 != (Object)null)
				{
					val5.enableAutoSizing = true;
					val5.fontSizeMin = 10f;
					val5.fontSizeMax = 18f;
					val5.richText = true;
					val5.text = BuildYesButtonText();
				}
				if ((Object)(object)val6 != (Object)null)
				{
					val6.enableAutoSizing = true;
					val6.fontSizeMin = 10f;
					val6.fontSizeMax = 18f;
					val6.richText = true;
					val6.text = BuildNoButtonText();
				}
				Log("Popup visual style applied.");
			}
			catch (Exception ex)
			{
				Log("Failed to apply popup visual style:\n" + ex);
			}
		}

		private static void OnResetSelected()
		{
			try
			{
				UnifiedPopup.Pop();
				ResetMainConfigToDefaults();
				_lastDecision.Value = "ResetToDefaults";
				MarkCurrentVersionHandled();
				Log("Player selected reset to defaults.");
			}
			catch (Exception ex)
			{
				Log("Error while processing reset selection:\n" + ex);
			}
			finally
			{
				_promptOpen = false;
			}
		}

		private static void OnKeepSelected()
		{
			try
			{
				UnifiedPopup.Pop();
				_lastDecision.Value = "KeepCurrentSettings";
				MarkCurrentVersionHandled();
				Log("Player selected keep current settings.");
			}
			catch (Exception ex)
			{
				Log("Error while processing keep selection:\n" + ex);
			}
			finally
			{
				_promptOpen = false;
			}
		}

		public static void ResetMainConfigToDefaults()
		{
			EnsureInitialized();
			int num = 0;
			int num2 = 0;
			List<Exception> list = new List<Exception>();
			foreach (KeyValuePair<ConfigDefinition, ConfigEntryBase> item in _mainConfig)
			{
				num2++;
				ConfigEntryBase value = item.Value;
				try
				{
					object boxedValue = value.BoxedValue;
					object defaultValue = value.DefaultValue;
					if (!object.Equals(boxedValue, defaultValue))
					{
						value.BoxedValue = defaultValue;
						num++;
					}
				}
				catch (Exception ex)
				{
					list.Add(ex);
					Log($"Failed to reset config entry: [{item.Key.Section}] {item.Key.Key}\n{ex}");
				}
			}
			_mainConfig.Save();
			try
			{
				_onResetApplied?.Invoke();
			}
			catch (Exception ex2)
			{
				list.Add(ex2);
				Log("Failed to apply config values after reset:\n" + ex2);
			}
			Log($"Reset finished. Changed={num}, Total={num2}, Errors={list.Count}");
		}

		public static void MarkCurrentVersionHandled()
		{
			EnsureInitialized();
			_lastHandledVersion.Value = _modVersion;
			_internalConfig.Save();
			Log("Marked version handled: " + _modVersion);
		}

		private static void EnsureInitialized()
		{
			if (_initialized)
			{
				return;
			}
			throw new InvalidOperationException("ConfigVersionManager is not initialized. Call Initialize() first.");
		}
	}
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	public static class DeleteFolder
	{
		private const bool EnableLogs = false;

		private static readonly string FolderToDelete = Path.Combine(Paths.ConfigPath, "DistantOriginsTranslations", "Magic_Supremacy");

		public static void Run()
		{
			try
			{
				if (!Directory.Exists(FolderToDelete))
				{
					Log("Old folder not found: " + FolderToDelete);
					return;
				}
				Directory.Delete(FolderToDelete, recursive: true);
				Log("Deleted old folder: " + FolderToDelete);
			}
			catch (Exception arg)
			{
				Magic_SupremacyPlugin.Magic_SupremacyLogger.LogWarning((object)$"[DeleteFolder] Failed to delete old folder: {FolderToDelete}\n{arg}");
			}
		}

		private static void Log(string message)
		{
		}
	}
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	public static class InspirationSystemConfigs
	{
		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
		private sealed class ExternalDefinitionPack
		{
			public string PackId;

			public string DisplayName;

			public string ExternalDefinitionPath;

			public string GeneratedConfigPath;

			public string DefaultSourcesRaw;

			public string DefaultConsumersRaw;

			public ConfigFile GeneratedConfig;

			public ConfigEntry<string> GeneratedSourcesConfig;

			public ConfigEntry<string> GeneratedConsumersConfig;

			public ConfigEntry<string> ProxySourcesEntry;

			public ConfigEntry<string> ProxyConsumersEntry;
		}

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
		private sealed class EditableSourceRow
		{
			public string DisplayName;

			public string SourceTypeRaw;

			public string SourceName;

			public bool ActivatesInspiration;

			public string GainPercentRaw;

			public string MaxBonusRaw;
		}

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
		private sealed class EditableConsumerRow
		{
			public string DisplayName;

			public string PrefabName;

			public string PrimaryCostRaw;

			public string SecondaryCostRaw;
		}

		private const bool EnableConfigDebugLogs = false;

		private const string InspirationFolderRelativePath = "DistantOrigins/Inspiration";

		private const string DefinitionsFolderName = "Definitions";

		private const string ConfigsFolderName = "Configs";

		private const string DefinitionSearchPattern = "*.cfg";

		private const string InspirationDefinitionSuffix = ".Inspiration";

		private const string InspirationDefinitionExtension = ".cfg";

		private const string ExampleDefinitionFileName = "YourModName.Inspiration.cfg";

		private static string _inspirationFolderPath;

		private static string _definitionsFolderPath;

		private static string _configsFolderPath;

		private const string ConfigSectionGeneral = "Inspiration - General";

		private const string ConfigSectionMagicSupremacy = "Inspiration - Magic Supremacy";

		private const int AbsoluteMaxInspirationPoints = 8;

		private const string ConfigSectionUI = "Inspiration - UI";

		private static readonly AcceptableValueList<string> ProgressTextModeOptions = new AcceptableValueList<string>(new string[4] { "Percent", "Fraction", "Hidden", "Points" });

		private static ConfigFile _mainConfig;

		private static ConfigEntry<bool> _enableInspirationSystem;

		private static ConfigEntry<float> _inspirationProgressPerPoint;

		private static ConfigEntry<float> _inspirationBaseGainPerSecond;

		private static ConfigEntry<int> _inspirationBaseMaxPoints;

		private static ConfigEntry<bool> _enableInspirationPointGainFx;

		private static ConfigEntry<string> _sourcesConfig;

		private static ConfigEntry<string> _consumersConfig;

		private static ConfigEntry<bool> _enableCustomUi;

		private static ConfigEntry<float> _inspirationUiPosX;

		private static ConfigEntry<float> _inspirationUiPosY;

		private static ConfigEntry<float> _inspirationUiIconScale;

		private static ConfigEntry<float> _inspirationUiTextOffsetX;

		private static ConfigEntry<float> _inspirationUiTextOffsetY;

		private static ConfigEntry<int> _inspirationUiTextFontSize;

		private static ConfigEntry<string> _inspirationUiTextColor;

		private static ConfigEntry<string> _inspirationUiProgressTextMode;

		private static bool _initialized;

		private static readonly List<ExternalDefinitionPack> ExternalPacks = new List<ExternalDefinitionPack>();

		private static readonly string[] SourceTypeDisplayOptions = new string[2] { "Status Effect", "Item Stat" };

		private static readonly HashSet<string> ExpandedSourceRows = new HashSet<string>();

		private static readonly HashSet<string> ExpandedConsumerRows = new HashSet<string>();

		private static void Log(string msg)
		{
		}

		public static void Initialize(ConfigFile config, ConfigSync configSync)
		{
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Expected O, but got Unknown
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Expected O, but got Unknown
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Expected O, but got Unknown
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Expected O, but got Unknown
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Expected O, but got Unknown
			//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Expected O, but got Unknown
			//IL_02f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fd: Expected O, but got Unknown
			//IL_0336: Unknown result type (might be due to invalid IL or missing references)
			//IL_0341: Expected O, but got Unknown
			//IL_037e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0389: Expected O, but got Unknown
			//IL_03ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_040a: Expected O, but got Unknown
			//IL_0444: Unknown result type (might be due to invalid IL or missing references)
			//IL_044f: Expected O, but got Unknown
			if (_initialized)
			{
				Log("Initialize called more than once. Ignored.");
				return;
			}
			_mainConfig = config;
			_inspirationFolderPath = Path.Combine(Paths.ConfigPath, "DistantOrigins/Inspiration");
			_definitionsFolderPath = Path.Combine(_inspirationFolderPath, "Definitions");
			_configsFolderPath = Path.Combine(_inspirationFolderPath, "Configs");
			Directory.CreateDirectory(_inspirationFolderPath);
			Directory.CreateDirectory(_definitionsFolderPath);
			Directory.CreateDirectory(_configsFolderPath);
			_enableInspirationSystem = BindSynced(_mainConfig, configSync, "Inspiration - General", "Enable Inspiration System", defaultValue: true, "Enable or disable the Inspiration system entirely.");
			_inspirationProgressPerPoint = BindSynced(_mainConfig, configSync, "Inspiration - General", "Inspiration progress per Point", 120f, "How much Inspiration progress is required for 1 whole Inspiration Point.");
			_inspirationBaseGainPerSecond = BindSynced(_mainConfig, configSync, "Inspiration - General", "Inspiration base progress gain per second", 1f, "Base Inspiration progress gained per second.");
			_inspirationBaseMaxPoints = BindSynced(_mainConfig, configSync, "Inspiration - General", "Inspiration base max Points", 1, $"Base maximum Inspiration Points granted upon activation. Max {8}.");
			_enableInspirationPointGainFx = BindSynced(_mainConfig, configSync, "Inspiration - General", "Enable Inspiration Point gain sound", defaultValue: true, "Spawn point-gain sound when a whole Inspiration Point is gained.");
			_enableCustomUi = BindSynced(_mainConfig, configSync, "Inspiration - UI", "EnableCustomUi", defaultValue: true, new ConfigDescription("Enable custom UI for Inspiration.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					DispName = "Enable Custom UI"
				}
			}), synchronizedSetting: false);
			_inspirationUiPosX = BindSynced(_mainConfig, configSync, "Inspiration - UI", "InspirationUiPosX", 200f, new ConfigDescription("X offset for Inspiration UI from bottom left corner.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					DispName = "UI Position X"
				}
			}), synchronizedSetting: false);
			_inspirationUiPosY = BindSynced(_mainConfig, configSync, "Inspiration - UI", "InspirationUiPosY", 185f, new ConfigDescription("Y offset for Inspiration UI from bottom left corner.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					DispName = "UI Position Y"
				}
			}), synchronizedSetting: false);
			_inspirationUiIconScale = BindSynced(_mainConfig, configSync, "Inspiration - UI", "InspirationUiIconScale", 2.3f, new ConfigDescription("Scale of the Inspiration icon.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					DispName = "Icon Scale"
				}
			}), synchronizedSetting: false);
			_inspirationUiTextOffsetX = BindSynced(_mainConfig, configSync, "Inspiration - UI", "InspirationUiTextOffsetX", 0f, new ConfigDescription("Horizontal offset for the Inspiration text.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					DispName = "Text Offset X"
				}
			}), synchronizedSetting: false);
			_inspirationUiTextOffsetY = BindSynced(_mainConfig, configSync, "Inspiration - UI", "InspirationUiTextOffsetY", -49f, new ConfigDescription("Vertical offset for the Inspiration text.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					DispName = "Text Offset Y"
				}
			}), synchronizedSetting: false);
			_inspirationUiTextFontSize = BindSynced(_mainConfig, configSync, "Inspiration - UI", "InspirationUiTextFontSize", 9, new ConfigDescription("Font size of the Inspiration text.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					DispName = "Text Font Size"
				}
			}), synchronizedSetting: false);
			_inspirationUiTextColor = BindSynced(_mainConfig, configSync, "Inspiration - UI", "InspirationUiTextColor", "#FFFFFF", new ConfigDescription("Text color of the Inspiration UI.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					DispName = "Text Color"
				}
			}), synchronizedSetting: false);
			_inspirationUiProgressTextMode = BindSynced(_mainConfig, configSync, "Inspiration - UI", "InspirationUiProgressTextMode", "Percent", new ConfigDescription("How Inspiration progress should be displayed.", (AcceptableValueBase)(object)ProgressTextModeOptions, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					DispName = "Progress Text Mode"
				}
			}), synchronizedSetting: false);
			_sourcesConfig = BindSynced(_mainConfig, configSync, "Inspiration - Magic Supremacy", "Sources", BuildDefaultSourcesConfig(), new ConfigDescription("Edit Magic Supremacy Inspiration sources. Stored format: DisplayName|SourceType|SourceName|ActivatesInspiration|GainPercent|MaxBonus.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					DispName = "",
					HideSettingName = true,
					HideDefaultButton = true,
					CustomDrawer = delegate
					{
						DrawCombinedConfig("Magic Supremacy", (ConfigEntryBase)(object)_sourcesConfig, (ConfigEntryBase)(object)_consumersConfig, BuildDefaultSourcesConfig(), BuildDefaultConsumersConfig());
					}
				}
			}));
			_consumersConfig = BindSynced(_mainConfig, configSync, "Inspiration - Magic Supremacy", "Consumers", BuildDefaultConsumersConfig(), new ConfigDescription("Edit Magic Supremacy Inspiration consumers. Stored format: DisplayName|PrefabName|PrimaryCost|SecondaryCost.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Browsable = false
				}
			}));
			_sourcesConfig.SettingChanged += [<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (object _, EventArgs _) =>
			{
				RebuildDefinitionsFromConfig();
			};
			_consumersConfig.SettingChanged += [<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (object _, EventArgs _) =>
			{
				RebuildDefinitionsFromConfig();
			};
			LoadExternalDefinitionPacks(configSync);
			RebuildDefinitionsFromConfig();
			_initialized = true;
			Log("InspirationSystemConfigs initialized.");
		}

		private static void LoadExternalDefinitionPacks(ConfigSync configSync)
		{
			ExternalPacks.Clear();
			if (string.IsNullOrWhiteSpace(_definitionsFolderPath) || !Directory.Exists(_definitionsFolderPath))
			{
				return;
			}
			string[] files = Directory.GetFiles(_definitionsFolderPath, "*.cfg", SearchOption.TopDirectoryOnly);
			foreach (string text in files)
			{
				string fileName = Path.GetFileName(text);
				if (string.Equals(fileName, "YourModName.Inspiration.cfg", StringComparison.OrdinalIgnoreCase))
				{
					Log("Skipped example definition file: " + fileName);
				}
				else
				{
					if (!IsValidInspirationDefinitionFileName(fileName))
					{
						continue;
					}
					string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(fileName);
					if (string.IsNullOrWhiteSpace(fileNameWithoutExtension))
					{
						continue;
					}
					string path = fileName;
					string generatedConfigPath = Path.Combine(_configsFolderPath, path);
					if (!TryReadExternalDefinitionFile(text, out var sourcesRaw, out var consumersRaw))
					{
						Log("Failed to read definition file: " + text);
						continue;
					}
					ExternalDefinitionPack externalDefinitionPack = CreateGeneratedPack(fileNameWithoutExtension, text, generatedConfigPath, sourcesRaw, consumersRaw, configSync);
					if (externalDefinitionPack != null)
					{
						ExternalPacks.Add(externalDefinitionPack);
					}
				}
			}
			Log($"External definition packs loaded: {ExternalPacks.Count}");
		}

		private static bool IsValidInspirationDefinitionFileName(string fileName)
		{
			if (string.IsNullOrWhiteSpace(fileName))
			{
				return false;
			}
			if (!fileName.EndsWith(".cfg", StringComparison.OrdinalIgnoreCase))
			{
				return false;
			}
			string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(fileName);
			if (string.IsNullOrWhiteSpace(fileNameWithoutExtension))
			{
				return false;
			}
			return fileNameWithoutExtension.EndsWith(".Inspiration", StringComparison.OrdinalIgnoreCase);
		}

		private static bool TryReadExternalDefinitionFile(string path, out string sourcesRaw, out string consumersRaw)
		{
			sourcesRaw = string.Empty;
			consumersRaw = string.Empty;
			if (string.IsNullOrWhiteSpace(path) || !File.Exists(path))
			{
				return false;
			}
			string[] array;
			try
			{
				array = File.ReadAllLines(path);
			}
			catch (Exception arg)
			{
				Log($"Exception while reading definition file '{path}': {arg}");
				return false;
			}
			List<string> list = new List<string>();
			List<string> list2 = new List<string>();
			string a = string.Empty;
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i]?.Trim() ?? string.Empty;
				if (!string.IsNullOrWhiteSpace(text) && !text.StartsWith("#", StringComparison.Ordinal))
				{
					if (text.Equals("[Sources]", StringComparison.OrdinalIgnoreCase))
					{
						a = "sources";
					}
					else if (text.Equals("[Consumers]", StringComparison.OrdinalIgnoreCase))
					{
						a = "consumers";
					}
					else if (text.StartsWith("[", StringComparison.Ordinal) && text.EndsWith("]", StringComparison.Ordinal))
					{
						a = string.Empty;
					}
					else if (string.Equals(a, "sources", StringComparison.OrdinalIgnoreCase))
					{
						list.Add(text);
					}
					else if (string.Equals(a, "consumers", StringComparison.OrdinalIgnoreCase))
					{
						list2.Add(text);
					}
				}
			}
			sourcesRaw = string.Join("\n", list);
			consumersRaw = string.Join("\n", list2);
			if (string.IsNullOrWhiteSpace(sourcesRaw))
			{
				return !string.IsNullOrWhiteSpace(consumersRaw);
			}
			return true;
		}

		private static ExternalDefinitionPack CreateGeneratedPack(string packId, string externalDefinitionPath, string generatedConfigPath, string defaultSourcesRaw, string defaultConsumersRaw, ConfigSync configSync)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Expected O, but got Unknown
			try
			{
				ConfigFile val = new ConfigFile(generatedConfigPath, true);
				string displayName = BuildDisplayNameFromPackId(packId);
				string section = "Inspiration - " + packId + " - Sources";
				string section2 = "Inspiration - " + packId + " - Consumers";
				ConfigEntry<string> val2 = BindSynced(val, configSync, section, "Sources", defaultSourcesRaw ?? string.Empty, new ConfigDescription("Generated editable Inspiration sources. This file is created from Definitions and preserves player/server edits.", (AcceptableValueBase)null, new object[1]
				{
					new ConfigurationManagerAttributes
					{
						Browsable = false
					}
				}));
				ConfigEntry<string> val3 = BindSynced(val, configSync, section2, "Consumers", defaultConsumersRaw ?? string.Empty, new ConfigDescription("Generated editable Inspiration consumers. This file is created from Definitions and preserves player/server edits.", (AcceptableValueBase)null, new object[1]
				{
					new ConfigurationManagerAttributes
					{
						Browsable = false
					}
				}));
				ExternalDefinitionPack obj = new ExternalDefinitionPack
				{
					PackId = packId,
					DisplayName = displayName,
					ExternalDefinitionPath = externalDefinitionPath,
					GeneratedConfigPath = generatedConfigPath,
					DefaultSourcesRaw = (defaultSourcesRaw ?? string.Empty),
					DefaultConsumersRaw = (defaultConsumersRaw ?? string.Empty),
					GeneratedConfig = val,
					GeneratedSourcesConfig = val2,
					GeneratedConsumersConfig = val3
				};
				val2.SettingChanged += [<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (object _, EventArgs _) =>
				{
					RebuildDefinitionsFromConfig();
				};
				val3.SettingChanged += [<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (object _, EventArgs _) =>
				{
					RebuildDefinitionsFromConfig();
				};
				CreateConfigManagerProxyEntries(obj);
				Log("Generated pack loaded: " + packId);
				return obj;
			}
			catch (Exception arg)
			{
				Log($"Exception while creating generated pack '{packId}': {arg}");
				return null;
			}
		}

		private static void CreateConfigManagerProxyEntries(ExternalDefinitionPack pack)
		{
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Expected O, but got Unknown
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Expected O, but got Unknown
			if (pack != null && _mainConfig != null)
			{
				string text = "Inspiration - " + pack.DisplayName;
				pack.ProxySourcesEntry = _mainConfig.Bind<string>(text, "External Sources", string.Empty, new ConfigDescription("Visual editor for generated external Inspiration sources. Real values are stored in Configs.", (AcceptableValueBase)null, new object[1]
				{
					new ConfigurationManagerAttributes
					{
						DispName = "",
						HideSettingName = true,
						HideDefaultButton = true,
						CustomDrawer = delegate
						{
							DrawCombinedConfig(pack.DisplayName, (ConfigEntryBase)(object)pack.GeneratedSourcesConfig, (ConfigEntryBase)(object)pack.GeneratedConsumersConfig, pack.DefaultSourcesRaw, pack.DefaultConsumersRaw);
						}
					}
				}));
				pack.ProxyConsumersEntry = _mainConfig.Bind<string>(text, "External Consumers", string.Empty, new ConfigDescription("Visual editor for generated external Inspiration consumers. Real values are stored in Configs.", (AcceptableValueBase)null, new object[1]
				{
					new ConfigurationManagerAttributes
					{
						DispName = "",
						HideSettingName = true,
						HideDefaultButton = true,
						Browsable = false
					}
				}));
			}
		}

		private static string BuildDisplayNameFromPackId(string packId)
		{
			if (string.IsNullOrWhiteSpace(packId))
			{
				return "External";
			}
			string text = packId;
			if (text.EndsWith(".Inspiration", StringComparison.OrdinalIgnoreCase))
			{
				text = text.Substring(0, text.Length - ".Inspiration".Length);
			}
			text = text.Replace("_", " ").Replace("-", " ").Replace(".", " ")
				.Trim();
			if (string.IsNullOrWhiteSpace(text))
			{
				return packId;
			}
			return text;
		}

		public static bool IsSystemEnabled()
		{
			return _enableInspirationSystem?.Value ?? true;
		}

		public static float GetProgressPerPoint()
		{
			return Mathf.Max(1f, _inspirationProgressPerPoint?.Value ?? 120f);
		}

		public static float GetBaseGainPerSecond()
		{
			return Mathf.Max(0f, _inspirationBaseGainPerSecond?.Value ?? 1f);
		}

		public static int GetBaseMaxPoints()
		{
			return Mathf.Clamp(_inspirationBaseMaxPoints?.Value ?? 1, 0, 8);
		}

		public static bool IsCustomUiEnabled()
		{
			return _enableCustomUi?.Value ?? true;
		}

		public static float GetUiPosX()
		{
			return _inspirationUiPosX?.Value ?? 200f;
		}

		public static float GetUiPosY()
		{
			return _inspirationUiPosY?.Value ?? 185f;
		}

		public static float GetUiIconScale()
		{
			return _inspirationUiIconScale?.Value ?? 2.3f;
		}

		public static float GetUiTextOffsetX()
		{
			return _inspirationUiTextOffsetX?.Value ?? 0f;
		}

		public static float GetUiTextOffsetY()
		{
			return _inspirationUiTextOffsetY?.Value ?? (-49f);
		}

		public static int GetUiTextFontSize()
		{
			return _inspirationUiTextFontSize?.Value ?? 9;
		}

		public static string GetUiTextColor()
		{
			return _inspirationUiTextColor?.Value ?? "#FFFFFF";
		}

		public static string GetUiProgressTextMode()
		{
			return _inspirationUiProgressTextMode?.Value ?? "Percent";
		}

		public static bool IsPointGainFxEnabled()
		{
			return _enableInspirationPointGainFx?.Value ?? true;
		}

		private static string BuildDefaultSourcesConfig()
		{
			return string.Join("\n", "Inspiration Ring SE|StatusEffect|SE_InspirationTrinket_DO|false|600|0", "Inspiration Ring Mistlands|ItemStat|ArmorInspirationTrinketMistlandsDO|false|20|0", "Inspiration Ring Ashlands|ItemStat|ArmorInspirationTrinketAshlandsDO|false|20|1", "Cookie Riko Moon SE|StatusEffect|SE_MoonCookieRiko_DO|false|20|0", "Cookie Riko Sun SE|StatusEffect|SE_SunCookieRiko_DO|false|20|1", "Mushroomcaller Tome|StatusEffect|SE_MushroomcallerBelt_DO|true|50|1", "Deathcaller Tome|StatusEffect|SE_DeathcallerBelt_DO|true|60|2", "Frostcaller Tome|StatusEffect|SE_FrostcallerBelt_DO|true|30|3", "Firecaller Tome|StatusEffect|SE_FirecallerBelt_DO|true|80|1", "Stonecaller Tome|StatusEffect|SE_StonecallerBelt_DO|true|60|2", "Lightcaller Tome|StatusEffect|SE_LightcallerBelt_DO|true|20|4", "Stormcaller Tome|StatusEffect|SE_StormcallerBelt_DO|true|100|1", "Lightcaller Set|StatusEffect|SE_LightcallerArmor_DO|false|20|1", "Totemcaller Utility|StatusEffect|SE_TotemcallerBelt_DO|false|10|0", "Windcaller Utility|StatusEffect|SE_WindcallerBelt_DO|false|10|1");
		}

		private static string BuildDefaultConsumersConfig()
		{
			return string.Join("\n", "Totemcaller Totemaku|StaffTotemcallerTotemDO|0|1", "Totemcaller Boomerang|StaffTotemcallerBoomerangDO|0|2", "Frostcaller Frostspike|StaffFrostcallerShotgunDO|0|4", "Firecaller Orbit|StaffFirecallerRingDO|0|2", "Windcaller Parasol|StaffWindcallerBuffDO|0|3", "Lightcaller Candle|StaffLightcallerHealDO|1|2", "Lightcaller Luminaris|StaffLightcallerSphereDO|0|1", "Stormcaller Thundersurge|StaffStormcallerShockerDO|0|2", "Bloodcaller Concord|StaffBloodcallerHealDO|0|1", "Bloodcaller Requiem|StaffBloodcallerShotgunDO|0|4");
		}

		private static ConfigEntry<T> BindSynced<[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)] T>(ConfigFile config, ConfigSync configSync, string section, string key, T defaultValue, string description, bool synchronizedSetting = true)
		{
			ConfigEntry<T> val = config.Bind<T>(section, key, defaultValue, description);
			if (configSync != null)
			{
				configSync.AddConfigEntry<T>(val).SynchronizedConfig = synchronizedSetting;
			}
			return val;
		}

		private static ConfigEntry<T> BindSynced<[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)] T>(ConfigFile config, ConfigSync configSync, string section, string key, T defaultValue, ConfigDescription description, bool synchronizedSetting = true)
		{
			ConfigEntry<T> val = config.Bind<T>(section, key, defaultValue, description);
			if (configSync != null)
			{
				configSync.AddConfigEntry<T>(val).SynchronizedConfig = synchronizedSetting;
			}
			return val;
		}

		private static void RebuildDefinitionsFromConfig()
		{
			List<InspirationSystem.InspirationSourceDef> list = new List<InspirationSystem.InspirationSourceDef>();
			List<InspirationSystem.InspirationUsageDef> list2 = new List<InspirationSystem.InspirationUsageDef>();
			HashSet<string> keys = new HashSet<string>(StringComparer.Ordinal);
			HashSet<string> keys2 = new HashSet<string>(StringComparer.Ordinal);
			List<InspirationSystem.InspirationSourceDef> list3 = new List<InspirationSystem.InspirationSourceDef>();
			List<InspirationSystem.InspirationUsageDef> list4 = new List<InspirationSystem.InspirationUsageDef>();
			ParseSourcesConfig(_sourcesConfig?.Value, list3);
			ParseConsumersConfig(_consumersConfig?.Value, list4);
			AddSourcesWithDuplicateProtection(list3, list, keys, isMainConfig: true);
			AddConsumersWithDuplicateProtection(list4, list2, keys2, isMainConfig: true);
			for (int i = 0; i < ExternalPacks.Count; i++)
			{
				ExternalDefinitionPack externalDefinitionPack = ExternalPacks[i];
				if (externalDefinitionPack != null)
				{
					List<InspirationSystem.InspirationSourceDef> list5 = new List<InspirationSystem.InspirationSourceDef>();
					List<InspirationSystem.InspirationUsageDef> list6 = new List<InspirationSystem.InspirationUsageDef>();
					ParseSourcesConfig(externalDefinitionPack.GeneratedSourcesConfig?.Value, list5);
					ParseConsumersConfig(externalDefinitionPack.GeneratedConsumersConfig?.Value, list6);
					AddSourcesWithDuplicateProtection(list5, list, keys, isMainConfig: false);
					AddConsumersWithDuplicateProtection(list6, list2, keys2, isMainConfig: false);
				}
			}
			InspirationSystem.SetDefinitions(list, list2);
			Log($"Definitions rebuilt. Sources={list.Count}, Consumers={list2.Count}, ExternalPacks={ExternalPacks.Count}.");
		}

		private static void AddSourcesWithDuplicateProtection(List<InspirationSystem.InspirationSourceDef> input, List<InspirationSystem.InspirationSourceDef> output, HashSet<string> keys, bool isMainConfig)
		{
			if (input == null || output == null || keys == null)
			{
				return;
			}
			for (int i = 0; i < input.Count; i++)
			{
				InspirationSystem.InspirationSourceDef inspirationSourceDef = input[i];
				if (inspirationSourceDef != null && !string.IsNullOrWhiteSpace(inspirationSourceDef.SourceName))
				{
					string text = inspirationSourceDef.SourceType.ToString() + ":" + inspirationSourceDef.SourceName;
					if (!keys.Add(text))
					{
						Log("Skipped duplicate Inspiration source '" + text + "' from " + (isMainConfig ? "main config" : "external config") + ".");
					}
					else
					{
						output.Add(inspirationSourceDef);
					}
				}
			}
		}

		private static void AddConsumersWithDuplicateProtection(List<InspirationSystem.InspirationUsageDef> input, List<InspirationSystem.InspirationUsageDef> output, HashSet<string> keys, bool isMainConfig)
		{
			if (input == null || output == null || keys == null)
			{
				return;
			}
			for (int i = 0; i < input.Count; i++)
			{
				InspirationSystem.InspirationUsageDef inspirationUsageDef = input[i];
				if (inspirationUsageDef != null && !string.IsNullOrWhiteSpace(inspirationUsageDef.PrefabName))
				{
					string prefabName = inspirationUsageDef.PrefabName;
					if (!keys.Add(prefabName))
					{
						Log("Skipped duplicate Inspiration consumer '" + prefabName + "' from " + (isMainConfig ? "main config" : "external config") + ".");
					}
					else
					{
						output.Add(inspirationUsageDef);
					}
				}
			}
		}

		private static void ParseSourcesConfig(string raw, List<InspirationSystem.InspirationSourceDef> result)
		{
			if (string.IsNullOrWhiteSpace(raw) || result == null)
			{
				return;
			}
			string[] array = raw.Split(new char[2] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (string.IsNullOrWhiteSpace(text) || text.StartsWith("#", StringComparison.Ordinal))
				{
					continue;
				}
				string[] array2 = text.Split(new char[1] { '|' });
				if (array2.Length >= 6)
				{
					string text2 = array2[0].Trim();
					if (!TryParseSourceType(array2[1], out var sourceType))
					{
						Log($"Invalid source type in line {i + 1}: '{array2[1]}'");
						continue;
					}
					string text3 = array2[2].Trim();
					if (string.IsNullOrWhiteSpace(text3))
					{
						Log($"Empty source name in line {i + 1}: '{text}'");
						continue;
					}
					bool activatesInspiration = ParseBoolSafe(array2[3], fallback: false);
					float inspirationGainPercentBonus = ParseFloatSafe(array2[4], 0f);
					int maxInspirationBonus = ParseIntSafe(array2[5], 0);
					result.Add(new InspirationSystem.InspirationSourceDef
					{
						DisplayName = (string.IsNullOrWhiteSpace(text2) ? text3 : text2),
						Name = text3,
						SourceType = sourceType,
						SourceName = text3,
						ActivatesInspiration = activatesInspiration,
						InspirationGainPercentBonus = inspirationGainPercentBonus,
						MaxInspirationBonus = maxInspirationBonus
					});
				}
				else if (array2.Length >= 5)
				{
					if (!TryParseSourceType(array2[0], out var sourceType2))
					{
						Log($"Invalid source type in line {i + 1}: '{array2[0]}'");
						continue;
					}
					string text4 = array2[1].Trim();
					if (string.IsNullOrWhiteSpace(text4))
					{
						Log($"Empty source name in line {i + 1}: '{text}'");
						continue;
					}
					bool activatesInspiration2 = ParseBoolSafe(array2[2], fallback: false);
					float inspirationGainPercentBonus2 = ParseFloatSafe(array2[3], 0f);
					int maxInspirationBonus2 = ParseIntSafe(array2[4], 0);
					result.Add(new InspirationSystem.InspirationSourceDef
					{
						DisplayName = text4,
						Name = text4,
						SourceType = sourceType2,
						SourceName = text4,
						ActivatesInspiration = activatesInspiration2,
						InspirationGainPercentBonus = inspirationGainPercentBonus2,
						MaxInspirationBonus = maxInspirationBonus2
					});
				}
				else
				{
					Log($"Invalid source config line {i + 1}: '{text}'");
				}
			}
		}

		private static void ParseConsumersConfig(string raw, List<InspirationSystem.InspirationUsageDef> result)
		{
			if (string.IsNullOrWhiteSpace(raw) || result == null)
			{
				return;
			}
			string[] array = raw.Split(new char[2] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (string.IsNullOrWhiteSpace(text) || text.StartsWith("#", StringComparison.Ordinal))
				{
					continue;
				}
				string[] array2 = text.Split(new char[1] { '|' });
				if (array2.Length >= 4)
				{
					string text2 = array2[0].Trim();
					string text3 = array2[1].Trim();
					if (string.IsNullOrWhiteSpace(text3))
					{
						Log($"Empty consumer prefab name in line {i + 1}: '{text}'");
						continue;
					}
					int num = Mathf.Max(0, ParseIntSafe(array2[2], 0));
					int num2 = Mathf.Max(0, ParseIntSafe(array2[3], 0));
					result.Add(new InspirationSystem.InspirationUsageDef
					{
						DisplayName = (string.IsNullOrWhiteSpace(text2) ? text3 : text2),
						PrefabName = text3,
						PrimaryInspirationCost = num,
						SecondaryInspirationCost = num2,
						PrimaryUsesInspiration = (num > 0),
						SecondaryUsesInspiration = (num2 > 0)
					});
				}
				else if (array2.Length >= 3)
				{
					string text4 = array2[0].Trim();
					if (string.IsNullOrWhiteSpace(text4))
					{
						Log($"Empty consumer prefab name in line {i + 1}: '{text}'");
						continue;
					}
					int num3 = Mathf.Max(0, ParseIntSafe(array2[1], 0));
					int num4 = Mathf.Max(0, ParseIntSafe(array2[2], 0));
					result.Add(new InspirationSystem.InspirationUsageDef
					{
						DisplayName = text4,
						PrefabName = text4,
						PrimaryInspirationCost = num3,
						SecondaryInspirationCost = num4,
						PrimaryUsesInspiration = (num3 > 0),
						SecondaryUsesInspiration = (num4 > 0)
					});
				}
				else
				{
					Log($"Invalid consumer config line {i + 1}: '{text}'");
				}
			}
		}

		private static bool TryParseSourceType(string raw, out InspirationSystem.InspirationSourceType sourceType)
		{
			sourceType = InspirationSystem.InspirationSourceType.StatusEffect;
			if (string.IsNullOrWhiteSpace(raw))
			{
				return false;
			}
			string a = raw.Trim().Replace(" ", "").Replace("_", "")
				.Replace("-", "");
			if (string.Equals(a, "StatusEffect", StringComparison.OrdinalIgnoreCase))
			{
				sourceType = InspirationSystem.InspirationSourceType.StatusEffect;
				return true;
			}
			if (string.Equals(a, "Item", StringComparison.OrdinalIgnoreCase) || string.Equals(a, "ItemStat", StringComparison.OrdinalIgnoreCase))
			{
				sourceType = InspirationSystem.InspirationSourceType.Item;
				return true;
			}
			return false;
		}

		private static bool ParseBoolSafe(string raw, bool fallback)
		{
			if (string.IsNullOrWhiteSpace(raw))
			{
				return fallback;
			}
			string text = raw.Trim();
			if (bool.TryParse(text, out var result))
			{
				return result;
			}
			if (string.Equals(text, "1", StringComparison.OrdinalIgnoreCase) || string.Equals(text, "yes", StringComparison.OrdinalIgnoreCase) || string.Equals(text, "on", StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			if (string.Equals(text, "0", StringComparison.OrdinalIgnoreCase) || string.Equals(text, "no", StringComparison.OrdinalIgnoreCase) || string.Equals(text, "off", StringComparison.OrdinalIgnoreCase))
			{
				return false;
			}
			return fallback;
		}

		private static int ParseIntSafe(string raw, int fallback)
		{
			if (string.IsNullOrWhiteSpace(raw))
			{
				return fallback;
			}
			if (int.TryParse(raw.Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				return result;
			}
			return fallback;
		}

		private static float ParseFloatSafe(string raw, float fallback)
		{
			if (string.IsNullOrWhiteSpace(raw))
			{
				return fallback;
			}
			if (float.TryParse(raw.Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				return result;
			}
			return fallback;
		}

		private static void DrawCombinedConfig(string modName, ConfigEntryBase sourcesEntry, ConfigEntryBase consumersEntry, string defaultSourcesRaw, string defaultConsumersRaw)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			GUILayout.BeginVertical(GUIStyle.op_Implicit("box"), Array.Empty<GUILayoutOption>());
			GUILayout.Label(string.IsNullOrWhiteSpace(modName) ? "Inspiration" : modName, new GUIStyle(GUI.skin.label)
			{
				fontStyle = (FontStyle)1
			}, Array.Empty<GUILayoutOption>());
			GUILayout.Space(4f);
			DrawSourcesConfig(sourcesEntry, defaultSourcesRaw, "Sources");
			GUILayout.Space(6f);
			DrawConsumersConfig(consumersEntry, defaultConsumersRaw, "Consumers");
			GUILayout.EndVertical();
		}

		private static void DrawSourcesConfig(ConfigEntryBase entry, string defaultRaw, string title)
		{
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Expected O, but got Unknown
			List<EditableSourceRow> list = ParseEditableSourceRows((entry.BoxedValue as string) ?? string.Empty);
			Dictionary<string, EditableSourceRow> dictionary = BuildSourceRowsByName(defaultRaw);
			bool flag = false;
			GUILayout.BeginVertical(GUIStyle.op_Implicit("box"), Array.Empty<GUILayoutOption>());
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label(string.IsNullOrWhiteSpace(title) ? "Inspiration Sources" : title, Array.Empty<GUILayoutOption>());
			GUILayout.FlexibleSpace();
			if (GUILayout.Button("Restore All Defaults", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(150f) }))
			{
				entry.BoxedValue = defaultRaw ?? string.Empty;
				ExpandedSourceRows.Clear();
				RebuildDefinitionsFromConfig();
				GUILayout.EndHorizontal();
				GUILayout.EndVertical();
				return;
			}
			GUILayout.EndHorizontal();
			for (int i = 0; i < list.Count; i++)
			{
				EditableSourceRow editableSourceRow = list[i];
				string item = "source_" + i;
				bool flag2 = ExpandedSourceRows.Contains(item);
				EditableSourceRow value;
				bool num = dictionary.TryGetValue(editableSourceRow.SourceName ?? string.Empty, out value);
				bool flag3 = num && !EditableSourceRowsEqual(editableSourceRow, value);
				bool flag4 = !num;
				string text = (string.IsNullOrWhiteSpace(editableSourceRow.DisplayName) ? editableSourceRow.SourceName : editableSourceRow.DisplayName);
				string text2 = (editableSourceRow.ActivatesInspiration ? "Activates" : "Bonus Only");
				string text3 = text + "  |  " + editableSourceRow.SourceTypeRaw + "  |  " + text2 + "  |  +" + editableSourceRow.GainPercentRaw + "%  |  +" + editableSourceRow.MaxBonusRaw + " Max";
				if (flag4)
				{
					text3 = "<color=#86D9FF>" + text3 + "</color>";
				}
				else if (flag3)
				{
					text3 = "<color=#FFD37A>" + text3 + "</color>";
				}
				GUILayout.BeginHorizontal(GUIStyle.op_Implicit("box"), Array.Empty<GUILayoutOption>());
				if (GUILayout.Button(flag2 ? "▼" : "▶", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(28f) }))
				{
					if (flag2)
					{
						ExpandedSourceRows.Remove(item);
					}
					else
					{
						ExpandedSourceRows.Add(item);
					}
				}
				GUILayout.Label(text3, new GUIStyle(GUI.skin.label)
				{
					richText = true
				}, Array.Empty<GUILayoutOption>());
				if (!flag4 && GUILayout.Button("R", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(28f) }))
				{
					editableSourceRow.DisplayName = value.DisplayName;
					editableSourceRow.SourceTypeRaw = value.SourceTypeRaw;
					editableSourceRow.SourceName = value.SourceName;
					editableSourceRow.ActivatesInspiration = value.ActivatesInspiration;
					editableSourceRow.GainPercentRaw = value.GainPercentRaw;
					editableSourceRow.MaxBonusRaw = value.MaxBonusRaw;
					flag = true;
				}
				if (GUILayout.Button("X", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(28f) }))
				{
					list.RemoveAt(i);
					flag = true;
					i--;
					GUILayout.EndHorizontal();
					continue;
				}
				GUILayout.EndHorizontal();
				if (flag2)
				{
					GUILayout.BeginVertical(GUIStyle.op_Implicit("box"), Array.Empty<GUILayoutOption>());
					flag |= DrawStringField("Display Name", ref editableSourceRow.DisplayName);
					flag |= DrawSourceTypeField(editableSourceRow);
					flag |= DrawStringField("Source Name", ref editableSourceRow.SourceName);
					bool activatesInspiration = editableSourceRow.ActivatesInspiration;
					editableSourceRow.ActivatesInspiration = GUILayout.Toggle(editableSourceRow.ActivatesInspiration, "Activates Inspiration", Array.Empty<GUILayoutOption>());
					if (activatesInspiration != editableSourceRow.ActivatesInspiration)
					{
						flag = true;
					}
					flag |= DrawStringField("Gain Percent", ref editableSourceRow.GainPercentRaw);
					flag |= DrawStringField("Max Bonus", ref editableSourceRow.MaxBonusRaw);
					GUILayout.EndVertical();
				}
			}
			GUILayout.Space(4f);
			if (GUILayout.Button("+ Add Source", Array.Empty<GUILayoutOption>()))
			{
				list.Add(new EditableSourceRow
				{
					DisplayName = "New Source",
					SourceTypeRaw = "StatusEffect",
					SourceName = "Prefab or Status Effect",
					ActivatesInspiration = false,
					GainPercentRaw = "0",
					MaxBonusRaw = "0"
				});
				flag = true;
			}
			GUILayout.EndVertical();
			if (flag)
			{
				entry.BoxedValue = SerializeEditableSourceRows(list);
			}
		}

		private static void DrawConsumersConfig(ConfigEntryBase entry, string defaultRaw, string title)
		{
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Expected O, but got Unknown
			List<EditableConsumerRow> list = ParseEditableConsumerRows((entry.BoxedValue as string) ?? string.Empty);
			Dictionary<string, EditableConsumerRow> dictionary = BuildConsumerRowsByPrefab(defaultRaw);
			bool flag = false;
			GUILayout.BeginVertical(GUIStyle.op_Implicit("box"), Array.Empty<GUILayoutOption>());
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label(string.IsNullOrWhiteSpace(title) ? "Inspiration Consumers" : title, Array.Empty<GUILayoutOption>());
			GUILayout.FlexibleSpace();
			if (GUILayout.Button("Restore All Defaults", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(150f) }))
			{
				entry.BoxedValue = defaultRaw ?? string.Empty;
				ExpandedConsumerRows.Clear();
				RebuildDefinitionsFromConfig();
				GUILayout.EndHorizontal();
				GUILayout.EndVertical();
				return;
			}
			GUILayout.EndHorizontal();
			for (int i = 0; i < list.Count; i++)
			{
				EditableConsumerRow editableConsumerRow = list[i];
				string item = "consumer_" + i;
				bool flag2 = ExpandedConsumerRows.Contains(item);
				EditableConsumerRow value;
				bool num = dictionary.TryGetValue(editableConsumerRow.PrefabName ?? string.Empty, out value);
				bool flag3 = num && !EditableConsumerRowsEqual(editableConsumerRow, value);
				bool flag4 = !num;
				string text = (string.IsNullOrWhiteSpace(editableConsumerRow.DisplayName) ? editableConsumerRow.PrefabName : editableConsumerRow.DisplayName);
				string text2 = text + "  |  Primary " + editableConsumerRow.PrimaryCostRaw + "  |  Secondary " + editableConsumerRow.SecondaryCostRaw;
				if (flag4)
				{
					text2 = "<color=#86D9FF>" + text2 + "</color>";
				}
				else if (flag3)
				{
					text2 = "<color=#FFD37A>" + text2 + "</color>";
				}
				GUILayout.BeginHorizontal(GUIStyle.op_Implicit("box"), Array.Empty<GUILayoutOption>());
				if (GUILayout.Button(flag2 ? "▼" : "▶", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(28f) }))
				{
					if (flag2)
					{
						ExpandedConsumerRows.Remove(item);
					}
					else
					{
						ExpandedConsumerRows.Add(item);
					}
				}
				GUILayout.Label(text2, new GUIStyle(GUI.skin.label)
				{
					richText = true
				}, Array.Empty<GUILayoutOption>());
				if (!flag4 && GUILayout.Button("R", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(28f) }))
				{
					editableConsumerRow.DisplayName = value.DisplayName;
					editableConsumerRow.PrefabName = value.PrefabName;
					editableConsumerRow.PrimaryCostRaw = value.PrimaryCostRaw;
					editableConsumerRow.SecondaryCostRaw = value.SecondaryCostRaw;
					flag = true;
				}
				if (GUILayout.Button("X", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(28f) }))
				{
					list.RemoveAt(i);
					flag = true;
					i--;
					GUILayout.EndHorizontal();
					continue;
				}
				GUILayout.EndHorizontal();
				if (flag2)
				{
					GUILayout.BeginVertical(GUIStyle.op_Implicit("box"), Array.Empty<GUILayoutOption>());
					flag |= DrawStringField("Display Name", ref editableConsumerRow.DisplayName);
					flag |= DrawStringField("Prefab Name", ref editableConsumerRow.PrefabName);
					flag |= DrawStringField("Primary Cost", ref editableConsumerRow.PrimaryCostRaw);
					flag |= DrawStringField("Secondary Cost", ref editableConsumerRow.SecondaryCostRaw);
					GUILayout.EndVertical();
				}
			}
			GUILayout.Space(4f);
			if (GUILayout.Button("+ Add Consumer", Array.Empty<GUILayoutOption>()))
			{
				list.Add(new EditableConsumerRow
				{
					DisplayName = "New Consumer",
					PrefabName = "PrefabNameHere",
					PrimaryCostRaw = "0",
					SecondaryCostRaw = "0"
				});
				flag = true;
			}
			GUILayout.EndVertical();
			if (flag)
			{
				entry.BoxedValue = SerializeEditableConsumerRows(list);
			}
		}

		private static Dictionary<string, EditableSourceRow> BuildSourceRowsByName(string raw)
		{
			Dictionary<string, EditableSourceRow> dictionary = new Dictionary<string, EditableSourceRow>();
			List<EditableSourceRow> list = ParseEditableSourceRows(raw);
			for (int i = 0; i < list.Count; i++)
			{
				EditableSourceRow editableSourceRow = list[i];
				if (editableSourceRow != null && !string.IsNullOrWhiteSpace(editableSourceRow.SourceName))
				{
					dictionary[editableSourceRow.SourceName] = editableSourceRow;
				}
			}
			return dictionary;
		}

		private static Dictionary<string, EditableConsumerRow> BuildConsumerRowsByPrefab(string raw)
		{
			Dictionary<string, EditableConsumerRow> dictionary = new Dictionary<string, EditableConsumerRow>();
			List<EditableConsumerRow> list = ParseEditableConsumerRows(raw);
			for (int i = 0; i < list.Count; i++)
			{
				EditableConsumerRow editableConsumerRow = list[i];
				if (editableConsumerRow != null && !string.IsNullOrWhiteSpace(editableConsumerRow.PrefabName))
				{
					dictionary[editableConsumerRow.PrefabName] = editableConsumerRow;
				}
			}
			return dictionary;
		}

		private static bool EditableSourceRowsEqual(EditableSourceRow a, EditableSourceRow b)
		{
			if (a == null || b == null)
			{
				return false;
			}
			if (string.Equals(a.DisplayName ?? string.Empty, b.DisplayName ?? string.Empty, StringComparison.Ordinal) && string.Equals(NormalizeSourceTypeForConfig(a.SourceTypeRaw), NormalizeSourceTypeForConfig(b.SourceTypeRaw), StringComparison.Ordinal) && string.Equals(a.SourceName ?? string.Empty, b.SourceName ?? string.Empty, StringComparison.Ordinal) && a.ActivatesInspiration == b.ActivatesInspiration && string.Equals(NormalizeFloatText(a.GainPercentRaw, "0"), NormalizeFloatText(b.GainPercentRaw, "0"), StringComparison.Ordinal))
			{
				return string.Equals(NormalizeIntText(a.MaxBonusRaw, "0"), NormalizeIntText(b.MaxBonusRaw, "0"), StringComparison.Ordinal);
			}
			return false;
		}

		private static bool EditableConsumerRowsEqual(EditableConsumerRow a, EditableConsumerRow b)
		{
			if (a == null || b == null)
			{
				return false;
			}
			if (string.Equals(a.DisplayName ?? string.Empty, b.DisplayName ?? string.Empty, StringComparison.Ordinal) && string.Equals(a.PrefabName ?? string.Empty, b.PrefabName ?? string.Empty, StringComparison.Ordinal) && string.Equals(NormalizeIntText(a.PrimaryCostRaw, "0"), NormalizeIntText(b.PrimaryCostRaw, "0"), StringComparison.Ordinal))
			{
				return string.Equals(NormalizeIntText(a.SecondaryCostRaw, "0"), NormalizeIntText(b.SecondaryCostRaw, "0"), StringComparison.Ordinal);
			}
			return false;
		}

		private static bool DrawStringField(string label, ref string value)
		{
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label(label, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(135f) });
			string text = GUILayout.TextField(value ?? string.Empty, Array.Empty<GUILayoutOption>());
			GUILayout.EndHorizontal();
			if (string.Equals(text, value ?? string.Empty, StringComparison.Ordinal))
			{
				return false;
			}
			value = text;
			return true;
		}

		private static bool DrawSourceTypeField(EditableSourceRow row)
		{
			int num = (IsItemSourceTypeRaw(row.SourceTypeRaw) ? 1 : 0);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label("Source Type", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(135f) });
			int num2 = GUILayout.SelectionGrid(num, SourceTypeDisplayOptions, 2, Array.Empty<GUILayoutOption>());
			GUILayout.EndHorizontal();
			if (num2 == num)
			{
				return false;
			}
			row.SourceTypeRaw = ((num2 == 1) ? "ItemStat" : "StatusEffect");
			return true;
		}

		private static bool IsItemSourceTypeRaw(string raw)
		{
			if (string.IsNullOrWhiteSpace(raw))
			{
				return false;
			}
			string a = raw.Trim().Replace(" ", "").Replace("_", "")
				.Replace("-", "");
			if (!string.Equals(a, "Item", StringComparison.OrdinalIgnoreCase))
			{
				return string.Equals(a, "ItemStat", StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}

		private static List<EditableSourceRow> ParseEditableSourceRows(string raw)
		{
			List<EditableSourceRow> list = new List<EditableSourceRow>();
			if (string.IsNullOrWhiteSpace(raw))
			{
				return list;
			}
			string[] array = raw.Split(new char[2] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (!string.IsNullOrWhiteSpace(text) && !text.StartsWith("#", StringComparison.Ordinal))
				{
					string[] array2 = text.Split(new char[1] { '|' });
					if (array2.Length >= 6)
					{
						list.Add(new EditableSourceRow
						{
							DisplayName = array2[0].Trim(),
							SourceTypeRaw = NormalizeSourceTypeForConfig(array2[1]),
							SourceName = array2[2].Trim(),
							ActivatesInspiration = ParseBoolSafe(array2[3], fallback: false),
							GainPercentRaw = NormalizeFloatText(array2[4], "0"),
							MaxBonusRaw = NormalizeIntText(array2[5], "0")
						});
					}
					else if (array2.Length >= 5)
					{
						string text2 = array2[1].Trim();
						list.Add(new EditableSourceRow
						{
							DisplayName = text2,
							SourceTypeRaw = NormalizeSourceTypeForConfig(array2[0]),
							SourceName = text2,
							ActivatesInspiration = ParseBoolSafe(array2[2], fallback: false),
							GainPercentRaw = NormalizeFloatText(array2[3], "0"),
							MaxBonusRaw = NormalizeIntText(array2[4], "0")
						});
					}
				}
			}
			return list;
		}

		private static List<EditableConsumerRow> ParseEditableConsumerRows(string raw)
		{
			List<EditableConsumerRow> list = new List<EditableConsumerRow>();
			if (string.IsNullOrWhiteSpace(raw))
			{
				return list;
			}
			string[] array = raw.Split(new char[2] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (!string.IsNullOrWhiteSpace(text) && !text.StartsWith("#", StringComparison.Ordinal))
				{
					string[] array2 = text.Split(new char[1] { '|' });
					if (array2.Length >= 4)
					{
						list.Add(new EditableConsumerRow
						{
							DisplayName = array2[0].Trim(),
							PrefabName = array2[1].Trim(),
							PrimaryCostRaw = NormalizeIntText(array2[2], "0"),
							SecondaryCostRaw = NormalizeIntText(array2[3], "0")
						});
					}
					else if (array2.Length >= 3)
					{
						string text2 = array2[0].Trim();
						list.Add(new EditableConsumerRow
						{
							DisplayName = text2,
							PrefabName = text2,
							PrimaryCostRaw = NormalizeIntText(array2[1], "0"),
							SecondaryCostRaw = NormalizeIntText(array2[2], "0")
						});
					}
				}
			}
			return list;
		}

		private static string SerializeEditableSourceRows(List<EditableSourceRow> rows)
		{
			if (rows == null || rows.Count == 0)
			{
				return string.Empty;
			}
			List<string> list = new List<string>();
			for (int i = 0; i < rows.Count; i++)
			{
				EditableSourceRow editableSourceRow = rows[i];
				if (editableSourceRow != null)
				{
					string text = SanitizeConfigField(editableSourceRow.SourceName);
					if (!string.IsNullOrWhiteSpace(text))
					{
						string text2 = SanitizeConfigField(string.IsNullOrWhiteSpace(editableSourceRow.DisplayName) ? text : editableSourceRow.DisplayName);
						string text3 = NormalizeSourceTypeForConfig(editableSourceRow.SourceTypeRaw);
						string text4 = (editableSourceRow.ActivatesInspiration ? "true" : "false");
						string text5 = NormalizeFloatText(editableSourceRow.GainPercentRaw, "0");
						string text6 = NormalizeIntText(editableSourceRow.MaxBonusRaw, "0");
						list.Add(text2 + "|" + text3 + "|" + text + "|" + text4 + "|" + text5 + "|" + text6);
					}
				}
			}
			return string.Join("\n", list);
		}

		private static string SerializeEditableConsumerRows(List<EditableConsumerRow> rows)
		{
			if (rows == null || rows.Count == 0)
			{
				return string.Empty;
			}
			List<string> list = new List<string>();
			for (int i = 0; i < rows.Count; i++)
			{
				EditableConsumerRow editableConsumerRow = rows[i];
				if (editableConsumerRow != null)
				{
					string text = SanitizeConfigField(editableConsumerRow.PrefabName);
					if (!string.IsNullOrWhiteSpace(text))
					{
						string text2 = SanitizeConfigField(string.IsNullOrWhiteSpace(editableConsumerRow.DisplayName) ? text : editableConsumerRow.DisplayName);
						string text3 = NormalizeIntText(editableConsumerRow.PrimaryCostRaw, "0");
						string text4 = NormalizeIntText(editableConsumerRow.SecondaryCostRaw, "0");
						list.Add(text2 + "|" + text + "|" + text3 + "|" + text4);
					}
				}
			}
			return string.Join("\n", list);
		}

		private static string NormalizeSourceTypeForConfig(string raw)
		{
			if (IsItemSourceTypeRaw(raw))
			{
				return "ItemStat";
			}
			return "StatusEffect";
		}

		private static string NormalizeIntText(string raw, string fallback)
		{
			return Mathf.Max(0, ParseIntSafe(raw, ParseIntSafe(fallback, 0))).ToString(CultureInfo.InvariantCulture);
		}

		private static string NormalizeFloatText(string raw, string fallback)
		{
			return ParseFloatSafe(raw, ParseFloatSafe(fallback, 0f)).ToString("0.##", CultureInfo.InvariantCulture);
		}

		private static string SanitizeConfigField(string raw)
		{
			if (string.IsNullOrEmpty(raw))
			{
				return string.Empty;
			}
			return raw.Replace("|", "").Replace("\r", "").Replace("\n", "")
				.Trim();
		}
	}
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	public static class InspirationSystemUI
	{
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		private static class DevLog
		{
			public const bool Enabled = false;

			public const bool Lifecycle = true;

			public const bool Build = true;

			public const bool Update = false;

			public const bool Assets = true;

			public const bool Filter = true;
		}

		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		private enum InspirationProgressTextMode
		{
			Percent,
			Fraction,
			Hidden,
			Points
		}

		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		private sealed class UiPresetDef
		{
			public float PosX;

			public float PosY;

			public float IconScale;

			public float TextOffsetX;

			public float TextOffsetY;

			public int TextFontSize;

			[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(1)]
			public string TextColor;
		}

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
		private sealed class SlotRefs
		{
			public RectTransform Root;

			public Image MaxIcon;

			public Image ActiveIcon;

			public GameObject CooldownObject;

			public TMP_Text PrimaryText;

			public TMP_Text TimeText;
		}

		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		[HarmonyPatch(typeof(Hud), "Update")]
		private static class InspirationSystemUI_Hud_Update_Patch
		{
			[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
			private static void Postfix(Hud __instance)
			{
				if (_initialized)
				{
					ManualUpdate();
				}
			}
		}

		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		[HarmonyPatch(typeof(Hud), "UpdateStatusEffects")]
		private static class InspirationSystemUI_Hud_UpdateStatusEffects_Patch
		{
			[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
			private static void Prefix(List<StatusEffect> statusEffects)
			{
				if (!_initialized || !IsCustomUiEnabled() || statusEffects == null || statusEffects.Count == 0)
				{
					return;
				}
				for (int num = statusEffects.Count - 1; num >= 0; num--)
				{
					StatusEffect val = statusEffects[num];
					if (ShouldHideFromVanillaHud(val))
					{
						if (_filterLogOnce.Add(val.NameHash()))
						{
							LogFilter("Hidden vanilla HUD icon for '" + ((Object)val).name + "'.");
						}
						statusEffects.RemoveAt(num);
					}
				}
			}
		}

		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		[HarmonyPatch(typeof(Hud), "OnDestroy")]
		private static class InspirationSystemUI_Hud_OnDestroy_Patch
		{
			private static void Prefix()
			{
				CleanupUi();
				LogLifecycle("HUD destroyed. Inspiration UI cleaned up.");
			}
		}

		private const string InspirationMaxIconPrefix = "Inspiration_Max_";

		private const string InspirationActiveIconPrefix = "Inspiration_Active_";

		private const string InspirationIconSuffix = "_DO";

		private const int InspirationIconMinIndex = 0;

		private const int InspirationIconMaxIndex = 8;

		private static readonly Dictionary<int, Sprite> _inspirationMaxSprites = new Dictionary<int, Sprite>();

		private static readonly Dictionary<int, Sprite> _inspirationActiveSprites = new Dictionary<int, Sprite>();

		private static bool _inspirationSpritesLoaded;

		private static bool _initialized;

		private static bool _uiBuilt;

		private static GameObject _rootObject;

		private static RectTransform _rootRect;

		private static Hud _lastHud;

		private static SlotRefs _inspirationSlot;

		private static readonly HashSet<int> _filterLogOnce = new HashSet<int>();

		private static bool _lastInspirationVisible;

		private static string _lastInspirationText = string.Empty;

		private static Sprite _lastInspirationMaxSprite;

		private static Sprite _lastInspirationActiveSprite;

		private static void LogLifecycle(string msg)
		{
		}

		private static void LogBuild(string msg)
		{
		}

		private static void LogUpdate(string msg)
		{
		}

		private static void LogAssets(string msg)
		{
		}

		private static void LogFilter(string msg)
		{
		}

		public static void Initialize()
		{
			if (_initialized)
			{
				LogLifecycle("Initialize called more than once. Ignored.");
				return;
			}
			LoadInspirationSprites();
			_initialized = true;
			LogLifecycle("InspirationSystemUI initialized.");
		}

		public static bool IsCustomUiEnabled()
		{
			if (_initialized)
			{
				return InspirationSystemConfigs.IsCustomUiEnabled();
			}
			return false;
		}

		private static void LoadInspirationSprites()
		{
			_inspirationSpritesLoaded = true;
			_inspirationMaxSprites.Clear();
			_inspirationActiveSprites.Clear();
			AssetBundle mainAssetBundle = Magic_SupremacyPlugin.MainAssetBundle;
			if ((Object)(object)mainAssetBundle == (Object)null)
			{
				LogAssets("MainAssetBundle is null. Inspiration sprites could not be loaded.");
				return;
			}
			for (int i = 0; i <= 8; i++)
			{
				string text = string.Format("{0}{1}{2}", "Inspiration_Max_", i, "_DO");
				string text2 = string.Format("{0}{1}{2}", "Inspiration_Active_", i, "_DO");
				try
				{
					Sprite val = mainAssetBundle.LoadAsset<Sprite>(text);
					if ((Object)(object)val != (Object)null)
					{
						_inspirationMaxSprites[i] = val;
						LogAssets("Loaded Inspiration max sprite '" + text + "'.");
					}
					else
					{
						LogAssets("Inspiration max sprite not found: '" + text + "'.");
					}
				}
				catch (Exception arg)
				{
					LogAssets($"Exception while loading Inspiration max sprite '{text}': {arg}");
				}
				try
				{
					Sprite val2 = mainAssetBundle.LoadAsset<Sprite>(text2);
					if ((Object)(object)val2 != (Object)null)
					{
						_inspirationActiveSprites[i] = val2;
						LogAssets("Loaded Inspiration active sprite '" + text2 + "'.");
					}
					else
					{
						LogAssets("Inspiration active sprite not found: '" + text2 + "'.");
					}
				}
				catch (Exception arg2)
				{
					LogAssets($"Exception while loading Inspiration active sprite '{text2}': {arg2}");
				}
			}
		}

		private static Sprite GetInspirationMaxSprite(int maxPoints)
		{
			if (!_inspirationSpritesLoaded)
			{
				LoadInspirationSprites();
			}
			int key = Mathf.Clamp(maxPoints, 0, 8);
			if (_inspirationMaxSprites.TryGetValue(key, out var value))
			{
				return value;
			}
			if (_inspirationMaxSprites.TryGetValue(0, out var value2))
			{
				return value2;
			}
			return null;
		}

		private static Sprite GetInspirationActiveSprite(int currentPoints)
		{
			if (!_inspirationSpritesLoaded)
			{
				LoadInspirationSprites();
			}
			int key = Mathf.Clamp(currentPoints, 0, 8);
			if (_inspirationActiveSprites.TryGetValue(key, out var value))
			{
				return value;
			}
			if (_inspirationActiveSprites.TryGetValue(0, out var value2))
			{
				return value2;
			}
			return null;
		}

		private static UiPresetDef BuildInspirationPreset()
		{
			return new UiPresetDef
			{
				PosX = InspirationSystemConfigs.GetUiPosX(),
				PosY = InspirationSystemConfigs.GetUiPosY(),
				IconScale = InspirationSystemConfigs.GetUiIconScale(),
				TextOffsetX = InspirationSystemConfigs.GetUiTextOffsetX(),
				TextOffsetY = InspirationSystemConfigs.GetUiTextOffsetY(),
				TextFontSize = InspirationSystemConfigs.GetUiTextFontSize(),
				TextColor = InspirationSystemConfigs.GetUiTextColor()
			};
		}

		private static void EnsureUiBuilt()
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			if (_initialized)
			{
				Hud instance = Hud.instance;
				if (!((Object)(object)instance == (Object)null) && !((Object)(object)instance.m_rootObject == (Object)null) && !((Object)(object)instance.m_statusEffectTemplate == (Object)null) && (!_uiBuilt || !((Object)(object)_lastHud == (Object)(object)instance) || !((Object)(object)_rootObject != (Object)null)))
				{
					CleanupUi();
					_lastHud = instance;
					_rootObject = new GameObject("Magic_Supremacy_InspirationSystemUI");
					_rootRect = _rootObject.AddComponent<RectTransform>();
					((Transform)_rootRect).SetParent(instance.m_rootObject.transform, false);
					_rootRect.anchorMin = Vector2.zero;
					_rootRect.anchorMax = Vector2.one;
					_rootRect.offsetMin = Vector2.zero;
					_rootRect.offsetMax = Vector2.zero;
					((Transform)_rootRect).SetAsLastSibling();
					_inspirationSlot = CreateSlot("InspirationSlot");
					_uiBuilt = true;
					LogBuild("Inspiration UI root and slot created.");
				}
			}
		}

		private static SlotRefs CreateSlot(string objectName)
		{
			RectTransform val = Object.Instantiate<RectTransform>(Hud.instance.m_statusEffectTemplate, (Transform)(object)_rootRect);
			((Object)((Component)val).gameObject).name = objectName;
			((Component)val).gameObject.SetActive(true);
			Image obj = FindChildComponent<Image>(val, "Icon");
			Transform val2 = ((Transform)val).Find("Cooldown");
			TMP_Text timeText = FindChildComponent<TMP_Text>(val, "TimeText");
			TMP_Text val3 = FindPrimaryText(val);
			Image val4 = obj;
			Image val5 = null;
			if ((Object)(object)val4 != (Object)null)
			{
				((Object)((Component)val4).gameObject).name = "MaxIcon";
				((Component)val4).gameObject.SetActive(true);
				GameObject obj2 = Object.Instantiate<GameObject>(((Component)val4).gameObject, ((Component)val4).transform.parent);
				((Object)obj2).name = "ActiveIcon";
				val5 = obj2.GetComponent<Image>();
				RectTransform rectTransform = ((Graphic)val4).rectTransform;
				RectTransform rectTransform2 = ((Graphic)val5).rectTransform;
				CopyRectTransform(rectTransform, rectTransform2);
				((Component)val4).transform.SetAsFirstSibling();
				((Component)val5).transform.SetSiblingIndex(((Component)val4).transform.GetSiblingIndex() + 1);
				if ((Object)(object)val3 != (Object)null)
				{
					val3.transform.SetAsLastSibling();
				}
			}
			SlotRefs slotRefs = new SlotRefs
			{
				Root = val,
				MaxIcon = val4,
				ActiveIcon = val5,
				CooldownObject = (((Object)(object)val2 != (Object)null) ? ((Component)val2).gameObject : null),
				PrimaryText = val3,
				TimeText = timeText
			};
			if ((Object)(object)slotRefs.TimeText != (Object)null)
			{
				((Component)slotRefs.TimeText).gameObject.SetActive(false);
			}
			if ((Object)(object)slotRefs.CooldownObject != (Object)null)
			{
				slotRefs.CooldownObject.SetActive(false);
			}
			return slotRefs;
		}

		private static void CleanupUi()
		{
			if ((Object)(object)_rootObject != (Object)null)
			{
				Object.Destroy((Object)(object)_rootObject);
			}
			_rootObject = null;
			_rootRect = null;
			_inspirationSlot = null;
			_uiBuilt = false;
			_lastHud = null;
			_lastInspirationVisible = false;
			_lastInspirationText = string.Empty;
			_lastInspirationMaxSprite = null;
			_lastInspirationActiveSprite = null;
		}

		private static void ManualUpdate()
		{
			if (!_initialized)
			{
				return;
			}
			EnsureUiBuilt();
			if (!_uiBuilt || (Object)(object)_rootObject == (Object)null || (Object)(object)_rootRect == (Object)null)
			{
				return;
			}
			Hud instance = Hud.instance;
			if ((Object)(object)instance == (Object)null || !instance.IsVisible() || Minimap.IsOpen())
			{
				if (_rootObject.activeSelf)
				{
					_rootObject.SetActive(false);
				}
				return;
			}
			if (!_rootObject.activeSelf)
			{
				_rootObject.SetActive(true);
			}
			if (!IsCustomUiEnabled())
			{
				SetSlotVisible(_inspirationSlot, visible: false);
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				SetSlotVisible(_inspirationSlot, visible: false);
			}
			else
			{
				UpdateInspirationSlot(localPlayer);
			}
		}

		private static void UpdateInspirationSlot(Player player)
		{
			if (_inspirationSlot == null)
			{
				return;
			}
			UiPresetDef preset = BuildInspirationPreset();
			ApplyPreset(_inspirationSlot, preset);
			if (!InspirationSystem.TryGetUIData(player, out var data))
			{
				SetSlotVisible(_inspirationSlot, visible: false);
				_lastInspirationVisible = false;
				return;
			}
			Sprite inspirationMaxSprite = GetInspirationMaxSprite(data.MaxPoints);
			Sprite inspirationActiveSprite = GetInspirationActiveSprite(data.CurrentPoints);
			string text = BuildInspirationDisplayText(data);
			SetSlotVisible(_inspirationSlot, visible: true);
			if ((Object)(object)_inspirationSlot.MaxIcon != (Object)null && (Object)(object)_lastInspirationMaxSprite != (Object)(object)inspirationMaxSprite)
			{
				_inspirationSlot.MaxIcon.sprite = inspirationMaxSprite;
				_lastInspirationMaxSprite = inspirationMaxSprite;
			}
			if ((Object)(object)_inspirationSlot.ActiveIcon != (Object)null && (Object)(object)_lastInspirationActiveSprite != (Object)(object)inspirationActiveSprite)
			{
				_inspirationSlot.ActiveIcon.sprite = inspirationActiveSprite;
				_lastInspirationActiveSprite = inspirationActiveSprite;
			}
			bool flag = string.IsNullOrEmpty(text);
			if ((Object)(object)_inspirationSlot.PrimaryText != (Object)null)
			{
				if (((Component)_inspirationSlot.PrimaryText).gameObject.activeSelf == flag)
				{
					((Component)_inspirationSlot.PrimaryText).gameObject.SetActive(!flag);
				}
				if (!flag && !string.Equals(_lastInspirationText, text, StringComparison.Ordinal))
				{
					_inspirationSlot.PrimaryText.text = text;
					_lastInspirationText = text;
				}
				else if (flag)
				{
					_lastInspirationText = string.Empty;
				}
			}
			_lastInspirationVisible = true;
			LogUpdate($"Inspiration UI updated. Points={data.CurrentPoints}/{data.MaxPoints}, Text='{text}'");
		}

		private static string BuildInspirationDisplayText(InspirationSystem.InspirationUIData data)
		{
			InspirationProgressTextMode inspirationProgressTextMode = ParseProgressTextMode(InspirationSystemConfigs.GetUiProgressTextMode());
			bool flag = data.MaxPoints > 0 && data.CurrentPoints >= data.MaxPoints;
			switch (inspirationProgressTextMode)
			{
			case InspirationProgressTextMode.Percent:
			{
				if (flag)
				{
					return "100%";
				}
				int num4 = Mathf.Clamp(Mathf.RoundToInt(data.ProgressNormalized * 100f), 0, 100);
				return $"{num4}%";
			}
			case InspirationProgressTextMode.Fraction:
			{
				if (flag)
				{
					return "100/100";
				}
				int num2 = Mathf.FloorToInt(data.Progress);
				int num3 = Mathf.RoundToInt(data.ProgressMax);
				return $"{num2}/{num3}";
			}
			case InspirationProgressTextMode.Hidden:
				return string.Empty;
			case InspirationProgressTextMode.Points:
				return $"{data.CurrentPoints}/{data.MaxPoints}";
			default:
			{
				if (flag)
				{
					return "100%";
				}
				int num = Mathf.Clamp(Mathf.RoundToInt(data.ProgressNormalized * 100f), 0, 100);
				return $"{num}%";
			}
			}
		}

		private static bool ShouldHideFromVanillaHud(StatusEffect statusEffect)
		{
			if ((Object)(object)statusEffect == (Object)null)
			{
				return false;
			}
			int num = statusEffect.NameHash();
			int visualStatusEffectNameHash = InspirationSystem.GetVisualStatusEffectNameHash();
			if (visualStatusEffectNameHash != 0 && num == visualStatusEffectNameHash)
			{
				return true;
			}
			return false;
		}

		private static InspirationProgressTextMode ParseProgressTextMode(string raw)
		{
			if (string.IsNullOrEmpty(raw))
			{
				return InspirationProgressTextMode.Percent;
			}
			if (Enum.TryParse<InspirationProgressTextMode>(raw, ignoreCase: true, out var result))
			{
				return result;
			}
			return InspirationProgressTextMode.Percent;
		}

		private static void ApplyPreset(SlotRefs slot, UiPresetDef preset)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			if (slot != null && !((Object)(object)slot.Root == (Object)null) && preset != null)
			{
				slot.Root.anchorMin = new Vector2(0f, 0f);
				slot.Root.anchorMax = new Vector2(0f, 0f);
				slot.Root.pivot = new Vector2(0f, 0f);
				slot.Root.anchoredPosition = new Vector2(preset.PosX, preset.PosY);
				((Transform)slot.Root).localScale = Vector3.one * preset.IconScale;
				if ((Object)(object)slot.MaxIcon != (Object)null)
				{
					((Component)slot.MaxIcon).gameObject.SetActive(true);
				}
				if ((Object)(object)slot.ActiveIcon != (Object)null)
				{
					((Component)slot.ActiveIcon).gameObject.SetActive(true);
				}
				if ((Object)(object)slot.PrimaryText != (Object)null)
				{
					slot.PrimaryText.rectTransform.anchoredPosition = new Vector2(preset.TextOffsetX, preset.TextOffsetY);
					slot.PrimaryText.enableAutoSizing = false;
					slot.PrimaryText.fontSize = preset.TextFontSize;
					slot.PrimaryText.fontSizeMin = preset.TextFontSize;
					slot.PrimaryText.fontSizeMax = preset.TextFontSize;
					((Graphic)slot.PrimaryText).color = ParseColorOrDefault(preset.TextColor, Color.white);
				}
				if ((Object)(object)slot.TimeText != (Object)null)
				{
					((Component)slot.TimeText).gameObject.SetActive(false);
				}
				if ((Object)(object)slot.CooldownObject != (Object)null)
				{
					slot.CooldownObject.SetActive(false);
				}
			}
		}

		private static void CopyRectTransform(RectTransform source, RectTransform target)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)source == (Object)null) && !((Object)(object)target == (Object)null))
			{
				target.anchorMin = source.anchorMin;
				target.anchorMax = source.anchorMax;
				target.pivot = source.pivot;
				target.anchoredPosition = source.anchoredPosition;
				target.sizeDelta = source.sizeDelta;
				target.offsetMin = source.offsetMin;
				target.offsetMax = source.offsetMax;
				((Transform)target).localScale = ((Transform)source).localScale;
				((Transform)target).localRotation = ((Transform)source).localRotation;
			}
		}

		private static Color ParseColorOrDefault(string raw, Color fallback)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(raw))
			{
				return fallback;
			}
			Color result = default(Color);
			if (ColorUtility.TryParseHtmlString(raw, ref result))
			{
				return result;
			}
			return fallback;
		}

		private static void SetSlotVisible(SlotRefs slot, bool visible)
		{
			if (!((Object)(object)slot?.Root == (Object)null) && ((Component)slot.Root).gameObject.activeSelf != visible)
			{
				((Component)slot.Root).gameObject.SetActive(visible);
			}
		}

		private static T FindChildComponent<[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)] T>(RectTransform root, string childName) where T : Component
		{
			if ((Object)(object)root == (Object)null || string.IsNullOrEmpty(childName))
			{
				return default(T);
			}
			Transform val = ((Transform)root).Find(childName);
			if ((Object)(object)val == (Object)null)
			{
				return default(T);
			}
			return ((Component)val).GetComponent<T>();
		}

		private static TMP_Text FindPrimaryText(RectTransform root)
		{
			if ((Object)(object)root == (Object)null)
			{
				return null;
			}
			TMP_Text[] componentsInChildren = ((Component)root).GetComponentsInChildren<TMP_Text>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				if (!((Object)(object)componentsInChildren[i] == (Object)null) && !string.Equals(((Object)componentsInChildren[i]).name, "TimeText", StringComparison.Ordinal))
				{
					return componentsInChildren[i];
				}
			}
			return null;
		}
	}
	internal enum DeathTriggerSpawnLocationMode
	{
		AtDeadCharacter,
		AtPlayersNearby
	}
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	internal sealed class DeathTriggerSpawnDef
	{
		internal string RequiredDeathSE;

		internal string RecipientPlayerSE;

		internal DeathTriggerSpawnLocationMode SpawnLocationMode;

		internal string SpawnPrefabName;

		internal float RecipientRadius;

		internal int RequiredDeathSEHash;

		internal int RecipientPlayerSEHash;

		internal void Cache()
		{
			RequiredDeathSEHash = ((!string.IsNullOrEmpty(RequiredDeathSE)) ? StringExtensionMethods.GetStableHashCode(RequiredDeathSE) : 0);
			RecipientPlayerSEHash = ((!string.IsNullOrEmpty(RecipientPlayerSE)) ? StringExtensionMethods.GetStableHashCode(RecipientPlayerSE) : 0);
		}

		internal string DebugString()
		{
			return "RequiredDeathSE=" + (RequiredDeathSE ?? "null") + ", RecipientPlayerSE=" + (string.IsNullOrEmpty(RecipientPlayerSE) ? "<empty>" : RecipientPlayerSE) + ", SpawnLocationMode=" + SpawnLocationMode.ToString() + ", SpawnPrefabName=" + (SpawnPrefabName ?? "null") + ", RecipientRadius=" + RecipientRadius;
		}
	}
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	internal static class DeathTriggerSpawnConfig
	{
		internal const bool DEBUG_LOG = false;

		private static ManualLogSource _log;

		internal static readonly DeathTriggerSpawnDef[] Defs;

		internal static ManualLogSource Log => _log ?? (_log = Logger.CreateLogSource("DeathTriggerSpawn"));

		static DeathTriggerSpawnConfig()
		{
			Defs = new DeathTriggerSpawnDef[2]
			{
				new DeathTriggerSpawnDef
				{
					RequiredDeathSE = "SE_DeathcallerDeathTrigger_DO",
					RecipientPlayerSE = "SE_DeathcallerArmor_DO",
					SpawnLocationMode = DeathTriggerSpawnLocationMode.AtDeadCharacter,
					SpawnPrefabName = "aoe_deathcaller_death_poison_DO",
					RecipientRadius = 24f
				},
				new DeathTriggerSpawnDef
				{
					RequiredDeathSE = "SE_BloodcallerDeathTrigger_DO",
					RecipientPlayerSE = "SE_BloodcallerArmor_DO",
					SpawnLocationMode = DeathTriggerSpawnLocationMode.AtPlayersNearby,
					SpawnPrefabName = "aoe_bloodcaller_death_heal_DO",
					RecipientRadius = 20f
				}
			};
			for (int i = 0; i < Defs.Length; i++)
			{
				Defs[i].Cache();
			}
		}
	}
	[HarmonyPatch(typeof(Character), "OnDeath")]
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	internal static class DeathTriggerSpawn_Character_OnDeath
	{
		private static void Postfix(Character __instance)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance == (Object)null)
			{
				return;
			}
			try
			{
				SEMan sEMan = __instance.GetSEMan();
				if (sEMan == null)
				{
					return;
				}
				Vector3 position = ((Component)__instance).transform.position;
				for (int i = 0; i < DeathTriggerSpawnConfig.Defs.Length; i++)
				{
					DeathTriggerSpawnDef deathTriggerSpawnDef = DeathTriggerSpawnConfig.Defs[i];
					if (deathTriggerSpawnDef != null && deathTriggerSpawnDef.RequiredDeathSEHash != 0 && sEMan.HaveStatusEffect(deathTriggerSpawnDef.RequiredDeathSEHash))
					{
						ProcessDef(__instance, position, deathTriggerSpawnDef, i);
					}
				}
			}
			catch (Exception)
			{
			}
		}

		private static void ProcessDef(Character deadCharacter, Vector3 deathPosition, DeathTriggerSpawnDef def, int defIndex)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ZNetScene.instance == (Object)null)
			{
				return;
			}
			GameObject prefab = ZNetScene.instance.GetPrefab(def.SpawnPrefabName);
			if (!((Object)(object)prefab == (Object)null))
			{
				List<Player> nearbyPlayers = FindNearbyPlayers(deathPosition, def.RecipientRadius);
				if (def.SpawnLocationMode == DeathTriggerSpawnLocationMode.AtPlayersNearby)
				{
					ProcessAtPlayersNearby(deadCharacter, deathPosition, prefab, def, defIndex, nearbyPlayers);
				}
				else if (def.SpawnLocationMode == DeathTriggerSpawnLocationMode.AtDeadCharacter)
				{
					ProcessAtDeadCharacter(deadCharacter, deathPosition, prefab, def, defIndex, nearbyPlayers);
				}
			}
		}

		private static void ProcessAtPlayersNearby(Character deadCharacter, Vector3 deathPosition, GameObject prefab, DeathTriggerSpawnDef def, int defIndex, List<Player> nearbyPlayers)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			for (int i = 0; i < nearbyPlayers.Count; i++)
			{
				Player val = nearbyPlayers[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				if (def.RecipientPlayerSEHash != 0)
				{
					SEMan sEMan = ((Character)val).GetSEMan();
					if (sEMan == null || !sEMan.HaveStatusEffect(def.RecipientPlayerSEHash))
					{
						continue;
					}
				}
				SpawnAoe(prefab, ((Component)val).transform.position, (Character)(object)val);
				num++;
			}
		}

		private static void ProcessAtDeadCharacter(Character deadCharacter, Vector3 deathPosition, GameObject prefab, DeathTriggerSpawnDef def, int defIndex, List<Player> nearbyPlayers)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			Player val = SelectOwnerForCorpseSpawn(nearbyPlayers, deathPosition, def.RecipientPlayerSEHash);
			if (!((Object)(object)val == (Object)null))
			{
				SpawnAoe(prefab, deathPosition, (Character)(object)val);
			}
		}

		private static List<Player> FindNearbyPlayers(Vector3 center, float radius)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			List<Player> list = new List<Player>();
			List<Player> allPlayers = Player.GetAllPlayers();
			if (allPlayers == null || allPlayers.Count == 0)
			{
				return list;
			}
			float num = radius * radius;
			for (int i = 0; i < allPlayers.Count; i++)
			{
				Player val = allPlayers[i];
				if (!((Object)(object)val == (Object)null))
				{
					Vector3 val2 = ((Component)val).transform.position - center;
					if (((Vector3)(ref val2)).sqrMagnitude <= num)
					{
						list.Add(val);
					}
				}
			}
			return list;
		}

		private static Player SelectOwnerForCorpseSpawn(List<Player> nearbyPlayers, Vector3 deathPosition, int preferredSEHash)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			Player val = null;
			float num = float.MaxValue;
			Player result = null;
			float num2 = float.MaxValue;
			for (int i = 0; i < nearbyPlayers.Count; i++)
			{
				Player val2 = nearbyPlayers[i];
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				Vector3 val3 = ((Component)val2).transform.position - deathPosition;
				float sqrMagnitude = ((Vector3)(ref val3)).sqrMagnitude;
				if (sqrMagnitude < num2)
				{
					num2 = sqrMagnitude;
					result = val2;
				}
				if (preferredSEHash != 0)
				{
					SEMan sEMan = ((Character)val2).GetSEMan();
					if (sEMan != null && sEMan.HaveStatusEffect(preferredSEHash) && sqrMagnitude < num)
					{
						num = sqrMagnitude;
						val = val2;
					}
				}
			}
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			return result;
		}

		private static GameObject SpawnAoe(GameObject prefab, Vector3 position, Character owner)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			Quaternion val = (((Object)(object)owner != (Object)null) ? ((Component)owner).transform.rotation : Quaternion.identity);
			GameObject val2 = Object.Instantiate<GameObject>(prefab, position, val);
			IProjectile val3 = val2.GetComponent<IProjectile>();
			if (val3 == null)
			{
				val3 = val2.GetComponentInChildren<IProjectile>(true);
			}
			if (val3 != null)
			{
				val3.Setup(owner, Vector3.zero, 0f, (HitData)null, (ItemData)null, (ItemData)null);
			}
			return val2;
		}

		private static string SafeName(Character character)
		{
			if (!((Object)(object)character != (Object)null))
			{
				return "null";
			}
			return ((Object)character).name;
		}
	}
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	public static class ShieldAutoRecharge
	{
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		private static class DevLog
		{
			public const bool Enabled = false;

			public const bool Lifecycle = true;

			public const bool Detection = true;

			public const bool Cooldown = true;

			public const bool Reapply = true;

			public const bool Tooltip = true;

			public const bool Perf = false;
		}

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
		public sealed class ShieldAutoRechargeController : MonoBehaviour
		{
			private Player _player;

			private float _updateAccumulator;

			private readonly Dictionary<int, ShieldAutoRechargeRuntimeState> _runtimeStates = new Dictionary<int, ShieldAutoRechargeRuntimeState>();

			public void Setup(Player player)
			{
				_player = player;
				_updateAccumulator = 0f;
				_runtimeStates.Clear();
				EnsureInitialized();
				for (int i = 0; i < Defs.Count; i++)
				{
					ShieldAutoRechargeDef shieldAutoRechargeDef = Defs[i];
					if (shieldAutoRechargeDef != null && shieldAutoRechargeDef.TriggerSeHash != 0)
					{
						_runtimeStates[shieldAutoRechargeDef.TriggerSeHash] = new ShieldAutoRechargeRuntimeState();
					}
				}
				LogLifecycle($"Controller setup complete. Runtime states = {_runtimeStates.Count}");
			}

			public void ManualUpdate(float dt)
			{
				if ((Object)(object)_player == (Object)null)
				{
					_player = ((Component)this).GetComponent<Player>();
					if ((Object)(object)_player == (Object)null)
					{
						return;
					}
				}
				EnsureInitialized();
				_updateAccumulator += dt;
				if (_updateAccumulator < 0.1f)
				{
					return;
				}
				float updateAccumulator = _updateAccumulator;
				_updateAccumulator = 0f;
				SEMan sEMan = ((Character)_player).GetSEMan();
				if (sEMan == null)
				{
					LogPerf("Skipping update because Player.GetSEMan() returned null.");
					return;
				}
				for (int i = 0; i < Defs.Count; i++)
				{
					ShieldAutoRechargeDef shieldAutoRechargeDef = Defs[i];
					if (shieldAutoRechargeDef == null || shieldAutoRechargeDef.TriggerSeHash == 0 || shieldAutoRechargeDef.ShieldSeHash == 0)
					{
						continue;
					}
					if (!_runtimeStates.TryGetValue(shieldAutoRechargeDef.TriggerSeHash, out var value) || value == null)
					{
						value = new ShieldAutoRechargeRuntimeState();
						_runtimeStates[shieldAutoRechargeDef.TriggerSeHash] = value;
						LogPerf("Created missing runtime state for trigger '" + shieldAutoRechargeDef.TriggerSeName + "'.");
					}
					bool flag = sEMan.HaveStatusEffect(shieldAutoRechargeDef.TriggerSeHash);
					bool flag2 = sEMan.HaveStatusEffect(shieldAutoRechargeDef.ShieldSeHash);
					if (value.LastObservedTriggerActive != flag)
					{
						LogDetection($"Trigger '{shieldAutoRechargeDef.TriggerSeName}' active = {flag}");
						value.LastObservedTriggerActive = flag;
					}
					if (value.LastObservedShieldActive != flag2)
					{
						LogDetection($"Shield '{shieldAutoRechargeDef.ShieldSeName}' active = {flag2}");
						value.LastObservedShieldActive = flag2;
					}
					if (!flag)
					{
						if (flag2)
						{
							if (TryRemoveStatusEffect(_player, shieldAutoRechargeDef.ShieldSeHash, shieldAutoRechargeDef.ShieldSeName))
							{
								LogReapply("Trigger '" + shieldAutoRechargeDef.TriggerSeName + "' is gone. Removed linked shield '" + shieldAutoRechargeDef.ShieldSeName + "'.");
							}
							else
							{
								LogReapply("Trigger '" + shieldAutoRechargeDef.TriggerSeName + "' is gone. Failed to remove linked shield '" + shieldAutoRechargeDef.ShieldSeName + "'.");
							}
							flag2 = false;
							value.LastObservedShieldActive = false;
						}
						if (value.WasTriggerActiveLastTick || value.WaitingForReapply || value.ReapplyTimer > 0f)
						{
							LogLifecycle("Trigger '" + shieldAutoRechargeDef.TriggerSeName + "' lost. Resetting recharge state.");
						}
						value.WasTriggerActiveLastTick = false;
						value.WaitingForReapply = false;
						value.ReapplyTimer = 0f;
						continue;
					}
					if (!value.WasTriggerActiveLastTick)
					{
						value.WasTriggerActiveLastTick = true;
						value.WaitingForReapply = false;
						value.ReapplyTimer = 0f;
						LogLifecycle("Trigger '" + shieldAutoRechargeDef.TriggerSeName + "' became active.");
						if (!flag2)
						{
							if (TryAddStatusEffect(_player, shieldAutoRechargeDef))
							{
								LogReapply("Immediate shield apply succeeded. Trigger='" + shieldAutoRechargeDef.TriggerSeName + "', Shield='" + shieldAutoRechargeDef.ShieldSeName + "'.");
							}
							else
							{
								LogReapply($"Immediate shield apply failed. Starting cooldown. Trigger='{shieldAutoRechargeDef.TriggerSeName}', Shield='{shieldAutoRechargeDef.ShieldSeName}', Cooldown={shieldAutoRechargeDef.ReapplyCooldown:0.##}s.");
								value.WaitingForReapply = true;
								value.ReapplyTimer = Mathf.Max(0f, shieldAutoRechargeDef.ReapplyCooldown);
							}
						}
						continue;
					}
					if (flag2)
					{
						if (value.WaitingForReapply || value.ReapplyTimer > 0f)
						{
							LogCooldown("Shield '" + shieldAutoRechargeDef.ShieldSeName + "' is active again. Clearing cooldown state.");
						}
						value.WaitingForReapply = false;
						value.ReapplyTimer = 0f;
						continue;
					}
					if (!value.WaitingForReapply)
					{
						value.WaitingForReapply = true;
						value.ReapplyTimer = Mathf.Max(0f, shieldAutoRechargeDef.ReapplyCooldown);
						LogCooldown($"Shield '{shieldAutoRechargeDef.ShieldSeName}' missing while trigger '{shieldAutoRechargeDef.TriggerSeName}' is active. Starting cooldown: {shieldAutoRechargeDef.ReapplyCooldown:0.##}s.");
						continue;
					}
					value.ReapplyTimer -= updateAccumulator;
					if (value.ReapplyTimer > 0f)
					{
						continue;
					}
					bool flag3 = sEMan.HaveStatusEffect(shieldAutoRechargeDef.TriggerSeHash);
					bool flag4 = !sEMan.HaveStatusEffect(shieldAutoRechargeDef.ShieldSeHash);
					if (!flag3)
					{
						LogCooldown("Cooldown finished, but trigger '" + shieldAutoRechargeDef.TriggerSeName + "' is no longer active. Reapply cancelled.");
						value.WaitingForReapply = false;
						value.ReapplyTimer = 0f;
						value.WasTriggerActiveLastTick = false;
						continue;
					}
					if (!flag4)
					{
						LogCooldown("Cooldown finished, but shield '" + shieldAutoRechargeDef.ShieldSeName + "' is already present. Reapply skipped.");
						value.WaitingForReapply = false;
						value.ReapplyTimer = 0f;
						continue;
					}
					if (TryAddStatusEffect(_player, shieldAutoRechargeDef))
					{
						LogReapply("Cooldown reapply succeeded. Trigger='" + shieldAutoRechargeDef.TriggerSeName + "', Shield='" + shieldAutoRechargeDef.ShieldSeName + "'.");
					}
					else
					{
						LogReapply("Cooldown reapply failed. Trigger='" + shieldAutoRechargeDef.TriggerSeName + "', Shield='" + shieldAutoRechargeDef.ShieldSeName + "'.");
					}
					value.WaitingForReapply = false;
					value.ReapplyTimer = 0f;
				}
			}

			public bool TryGetRuntimeState(int triggerSeHash, out ShieldAutoRechargeRuntimeState state)
			{
				return _runtimeStates.TryGetValue(triggerSeHash, out state);
			}
		}

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
		public struct ShieldAutoRechargeUIData
		{
			public bool IsActive;

			public string TriggerSeName;

			public string ShieldSeName;

			public float Cooldown;

			public float RemainingTime;

			public bool IsShieldActive;

			public bool IsRecharging;

			public float NormalizedCooldown;
		}

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
		public sealed class ShieldAutoRechargeDef
		{
			public string TriggerSeName;

			public string ShieldSeName;

			public float ReapplyCooldown;

			public string TooltipLabelKey;

			public bool ShowShieldValue;

			public SkillType ShieldSkillType;

			public int TriggerSeHash;

			public int ShieldSeHash;
		}

		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		public sealed class ShieldAutoRechargeRuntimeState
		{
			public bool WasTriggerActiveLastTick;

			public bool WaitingForReapply;

			public float ReapplyTimer;

			public bool LastObservedTriggerActive;

			public bool LastObservedShieldActive;
		}

		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		[HarmonyPatch(typeof(SE_Stats), "GetTooltipString")]
		private static class ShieldAutoRecharge_SEStats_GetTooltipString_Patch
		{
			[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
			private static void Postfix(SE_Stats __instance, ref string __result)
			{
				EnsureInitialized();
				if ((Object)(object)__instance == (Object)null)
				{
					return;
				}
				ShieldAutoRechargeDef defByTriggerSeHash = GetDefByTriggerSeHash(((StatusEffect)__instance).NameHash());
				if (defByTriggerSeHash == null)
				{
					return;
				}
				string text = BuildTooltipBlock(Player.m_localPlayer, defByTriggerSeHash);
				if (string.IsNullOrEmpty(text))
				{
					return;
				}
				if (string.IsNullOrEmpty(__result))
				{
					__result = text;
				}
				else
				{
					if (!__result.EndsWith("\n", StringComparison.Ordinal))
					{
						__result += "\n";
					}
					__result += text;
				}
				if (!_tooltipLogOnce.Contains(defByTriggerSeHash.TriggerSeHash))
				{
					_tooltipLogOnce.Add(defByTriggerSeHash.TriggerSeHash);
					LogTooltip("Added tooltip block for trigger SE '" + defByTriggerSeHash.TriggerSeName + "' using label key '" + defByTriggerSeHash.TooltipLabelKey + "'.");
				}
			}
		}

		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		[HarmonyPatch(typeof(Player), "Update")]
		private static class ShieldAutoRecharge_Player_Update_Patch
		{
			[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
			private static void Postfix(Player __instance)
			{
				EnsureInitialized();
				if (!((Object)(object)__instance == (Object)null) && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
				{
					ShieldAutoRechargeController orCreateController = GetOrCreateController(__instance);
					if (!((Object)(object)orCreateController == (Object)null))
					{
						orCreateController.ManualUpdate(Time.deltaTime);
					}
				}
			}
		}

		private const float CheckInterval = 0.1f;

		private const string LocSeconds = "$seconds_DO";

		private const string LocShieldDamage = "$se_shield_damage";

		private const string DefaultTooltipLabelKey = "$shield_auto_recharge_DO";

		private const string TooltipColor_ShieldAutoRecharge_Label = "#FFFFFF";

		private const string TooltipColor_ShieldAutoRecharge_Value = "#a19165";

		private const string TooltipColor_ShieldAutoRecharge_Seconds = "#FFFFFF";

		private static readonly List<ShieldAutoRechargeDef> Defs = new List<ShieldAutoRechargeDef>
		{
			new ShieldAutoRechargeDef
			{
				TriggerSeName = "SE_StonecallerArmor_DO",
				ShieldSeName = "SE_StonecallerShield_DO",
				ReapplyCooldown = 30f,
				TooltipLabelKey = "$shield_auto_recharge_DO",
				ShowShieldValue = true,
				ShieldSkillType = (SkillType)9
			},
			new ShieldAutoRechargeDef
			{
				TriggerSeName = "SE_TotemcallerArmor_DO",
				ShieldSeName = "SE_TotemcallerShield_DO",
				ReapplyCooldown = 12f,
				TooltipLabelKey = "$reactive_auto_recharge_DO",
				ShowShieldValue = false,
				ShieldSkillType = (SkillType)10
			},
			new ShieldAutoRechargeDef
			{
				TriggerSeName = "SE_FirecallerArmor_DO",
				ShieldSeName = "SE_FirecallerShield_DO",
				ReapplyCooldown = 15f,
				TooltipLabelKey = "$reactive_auto_recharge_DO",
				ShowShieldValue = false,
				ShieldSkillType = (SkillType)9
			}
		};

		private static bool _initialized;

		private static readonly HashSet<int> _tooltipLogOnce = new HashSet<int>();

		public static void Initialize()
		{
			EnsureInitialized();
		}

		private static void EnsureInitialized()
		{
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			if (_initialized)
			{
				return;
			}
			for (int i = 0; i < Defs.Count; i++)
			{
				ShieldAutoRechargeDef shieldAutoRechargeDef = Defs[i];
				if (shieldAutoRechargeDef != null)
				{
					shieldAutoRechargeDef.TriggerSeHash = ((!string.IsNullOrEmpty(shieldAutoRechargeDef.TriggerSeName)) ? StringExtensionMethods.GetStableHashCode(shieldAutoRechargeDef.TriggerSeName) : 0);
					shieldAutoRechargeDef.ShieldSeHash = ((!string.IsNullOrEmpty(shieldAutoRechargeDef.ShieldSeName)) ? StringExtensionMethods.GetStableHashCode(shieldAutoRechargeDef.ShieldSeName) : 0);
					LogPerf($"Initialized def[{i}] " + $"Trigger='{shieldAutoRechargeDef.TriggerSeName}' ({shieldAutoRechargeDef.TriggerSeHash}), " + $"Shield='{shieldAutoRechargeDef.ShieldSeName}' ({shieldAutoRechargeDef.ShieldSeHash}), " + $"Cooldown={shieldAutoRechargeDef.ReapplyCooldown:0.##}, " + "TooltipLabelKey='" + shieldAutoRechargeDef.TooltipLabelKey + "', " + $"ShowShieldValue={shieldAutoRechargeDef.ShowShieldValue}, " + $"ShieldSkillType={shieldAutoRechargeDef.ShieldSkillType}");
				}
			}
			_initialized = true;
			LogLifecycle($"ShieldAutoRecharge initialized. Def count = {Defs.Count}");
		}

		private static void LogLifecycle(string msg)
		{
		}

		private static void LogDetection(string msg)
		{
		}

		private static void LogCooldown(string msg)
		{
		}

		private static void LogReapply(string msg)
		{
		}

		private static void LogTooltip(string msg)
		{
		}

		private static void LogPerf(string msg)
		{
		}

		private static string Localize(string key)
		{
			if (string.IsNullOrEmpty(key))
			{
				return string.Empty;
			}
			if (Localization.instance == null)
			{
				return key;
			}
			return Localization.instance.Localize(key);
		}

		private static string ApplyColor(string raw, string hexColor)
		{
			if (string.IsNullOrEmpty(raw))
			{
				return string.Empty;
			}
			if (string.IsNullOrEmpty(hexColor))
			{
				return raw;
			}
			return "<color=" + hexColor + ">" + raw + "</color>";
		}

		private static string FormatNumber(float value)
		{
			if (Mathf.Approximately(value, Mathf.Round(value)))
			{
				return Mathf.RoundToInt(value).ToString();
			}
			return value.ToString("0.#");
		}

		private static string BuildRechargeTooltipLine(ShieldAutoRechargeDef def)
		{
			if (def == null)
			{
				return string.Empty;
			}
			string text = ApplyColor(Localize(string.IsNullOrEmpty(def.TooltipLabelKey) ? "$shield_auto_recharge_DO" : def.TooltipLabelKey), "#FFFFFF");
			string text2 = ApplyColor(FormatNumber(def.ReapplyCooldown), "#a19165");
			string text3 = ApplyColor(Localize("$seconds_DO"), "#FFFFFF");
			return text + ": " + text2 + " " + text3;
		}

		private static float GetShieldTooltipValue(Player player, ShieldAutoRechargeDef def)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			if (def == null || def.ShieldSeHash == 0)
			{
				return 0f;
			}
			StatusEffect statusEffectAsset = GetStatusEffectAsset(def.ShieldSeHash);
			SE_Shield val = (SE_Shield)(object)((statusEffectAsset is SE_Shield) ? statusEffectAsset : null);
			if (val == null)
			{
				return 0f;
			}
			float num = 0f;
			if ((Object)(object)player != (Object)null && (int)def.ShieldSkillType != 0)
			{
				Skills skills = ((Character)player).GetSkills();
				if (skills != null && Object.op_Implicit((Object)(object)skills))
				{
					num = skills.GetSkillLevel(def.ShieldSkillType);
				}
			}
			float num2 = val.m_absorbDamage + val.m_absorbDamagePerSkillLevel * num;
			if (Game.m_worldLevel > 0)
			{
				num2 += val.m_absorbDamageWorldLevel * (float)Game.m_worldLevel;
			}
			LogTooltip("Shield='" + def.ShieldSeName + "', " + $"Base={val.m_absorbDamage}, " + $"PerSkill={val.m_absorbDamagePerSkillLevel}, " + $"Skill={def.ShieldSkillType}, " + $"SkillLevel={num:0.##}, " + $"WorldLevel={Game.m_worldLevel}, " + $"WorldBonus={val.m_absorbDamageWorldLevel}, " + $"Final={num2:0.##}");
			return Mathf.Max(0f, num2);
		}

		private static string BuildShieldValueTooltipLine(Player player, ShieldAutoRechargeDef def)
		{
			if (def == null || !def.ShowShieldValue)
			{
				return string.Empty;
			}
			if (!(GetStatusEffectAsset(def.ShieldSeHash) is SE_Shield))
			{
				return string.Empty;
			}
			float shieldTooltipValue = GetShieldTooltipValue(player, def);
			string text = ApplyColor(Localize("$se_shield_damage"), "#FFFFFF");
			string text2 = ApplyColor(FormatNumber(shieldTooltipValue), "#a19165");
			return text + " " + text2;
		}

		private static string BuildTooltipBlock(Player player, ShieldAutoRechargeDef def)
		{
			if (def == null)
			{
				return string.Empty;
			}
			List<string> list = new List<string>();
			string text = BuildRechargeTooltipLine(def);
			if (!string.IsNullOrEmpty(text))
			{
				list.Add(text);
			}
			string text2 = BuildShieldValueTooltipLine(player, def);
			if (!string.IsNullOrEmpty(text2))
			{
				list.Add(text2);
			}
			if (list.Count == 0)
			{
				return string.Empty;
			}
			return string.Join("\n", list);
		}

		private static ShieldAutoRechargeDef GetDefByTriggerSeHash(int triggerSeHash)
		{
			if (triggerSeHash == 0)
			{
				return null;
			}
			for (int i = 0; i < Defs.Count; i++)
			{
				ShieldAutoRechargeDef shieldAutoRechargeDef = Defs[i];
				if (shieldAutoRechargeDef != null && shieldAutoRechargeDef.TriggerSeHash == triggerSeHash)
				{
					return shieldAutoRechargeDef;
				}
			}
			return null;
		}

		private static StatusEffect GetStatusEffectAsset(int seHash)
		{
			if (seHash == 0 || (Object)(object)ObjectDB.instance == (Object)null)
			{
				return null;
			}
			return ObjectDB.instance.GetStatusEffect(seHash);
		}

		private static bool TryAddStatusEffect(Player player, ShieldAutoRechargeDef def)
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null || def == null || def.ShieldSeHash == 0)
			{
				return false;
			}
			SEMan sEMan = ((Character)player).GetSEMan();
			if (sEMan == null)
			{
				LogReapply("Cannot add SE '" + def.ShieldSeName + "'. Player SEMan is null.");
				return false;
			}
			StatusEffect statusEffectAsset = GetStatusEffectAsset(def.ShieldSeHash);
			if ((Object)(object)statusEffectAsset == (Object)null)
			{
				LogReapply("Cannot add SE '" + def.ShieldSeName + "'. ObjectDB returned null.");
				return false;
			}
			float num = 0f;
			if ((int)def.ShieldSkillType != 0)
			{
				Skills skills = ((Character)player).GetSkills();
				if (skills != null && Object.op_Implicit((Object)(object)skills))
				{
					num = skills.GetSkillLevel(def.ShieldSkillType);
				}
			}
			StatusEffect val = sEMan.AddStatusEffect(statusEffectAsset, true, 1, num);
			bool flag = sEMan.HaveStatusEffect(def.ShieldSeHash);
			if ((Object)(object)val != (Object)null || flag)
			{
				LogReapply("AddStatusEffect succeeded. Shield='" + def.ShieldSeName + "', " + $"Skill={def.ShieldSkillType}, " + $"SkillLevel={num:0.##}");
				return true;
			}
			LogReapply("AddStatusEffect for '" + def.ShieldSeName + "' returned null and effect is still absent after call.");
			return false;
		}

		private static bool TryRemoveStatusEffect(Player player, int seHash, string seNameForLogs, bool quiet = true)
		{
			if ((Object)(object)player == (Object)null || seHash == 0)
			{
				return false;
			}
			SEMan sEMan = ((Character)player).GetSEMan();
			if (sEMan == null)
			{
				LogReapply("Cannot remove SE '" + seNameForLogs + "'. Player SEMan is null.");
				return false;
			}
			if (!sEMan.RemoveStatusEffect(seHash, quiet))
			{
				LogReapply("RemoveStatusEffect returned false for '" + seNameForLogs + "'.");
				return false;
			}
			return true;
		}

		public static ShieldAutoRechargeController GetOrCreateController(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return null;
			}
			EnsureInitialized();
			ShieldAutoRechargeController shieldAutoRechargeController = ((Component)player).GetComponent<ShieldAutoRechargeController>();
			if ((Object)(object)shieldAutoRechargeController == (Object)null)
			{
				shieldAutoRechargeController = ((Component)player).gameObject.AddComponent<ShieldAutoRechargeController>();
				shieldAutoRechargeController.Setup(player);
				LogLifecycle("Created ShieldAutoRechargeController on local player.");
			}
			return shieldAutoRechargeController;
		}

		public static bool TryGetController(Player player, out ShieldAutoRechargeController controller)
		{
			controller = null;
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			controller = ((Component)player).GetComponent<ShieldAutoRechargeController>();
			return (Object)(object)controller != (Object)null;
		}

		public static bool TryGetUIData(Player player, out List<ShieldAutoRechargeUIData> dataList)
		{
			dataList = null;
			if (!_initialized || (Object)(object)player == (Object)null)
			{
				return false;
			}
			if (!TryGetController(player, out var controller))
			{
				return false;
			}
			SEMan sEMan = ((Character)player).GetSEMan();
			if (sEMan == null)
			{
				return false;
			}
			dataList = new List<ShieldAutoRechargeUIData>();
			foreach (ShieldAutoRechargeDef def in Defs)
			{
				if (def != null && def.TriggerSeHash != 0 && def.ShieldSeHash != 0 && controller.TryGetRuntimeState(def.TriggerSeHash, out var state) && state != null && sEMan.HaveStatusEffect(def.TriggerSeHash))
				{
					bool isShieldActive = sEMan.HaveStatusEffect(def.ShieldSeHash);
					float num = Mathf.Max(0f, state.ReapplyTimer);
					float num2 = ((def.ReapplyCooldown > 0f) ? (1f - num / def.ReapplyCooldown) : 1f);
					dataList.Add(new ShieldAutoRechargeUIData
					{
						IsActive = true,
						TriggerSeName = def.TriggerSeName,
						ShieldSeName = def.ShieldSeName,
						Cooldown = def.ReapplyCooldown,
						RemainingTime = num,
						IsShieldActive = isShieldActive,
						IsRecharging = state.WaitingForReapply,
						NormalizedCooldown = Mathf.Clamp01(num2)
					});
				}
			}
			return dataList.Count > 0;
		}

		public static bool TryGetUIDataForTrigger(Player player, string triggerSeName, out ShieldAutoRechargeUIData data)
		{
			data = default(ShieldAutoRechargeUIData);
			if (string.IsNullOrEmpty(triggerSeName))
			{
				return false;
			}
			if (!TryGetUIData(player, out var dataList))
			{
				return false;
			}
			for (int i = 0; i < dataList.Count; i++)
			{
				if (string.Equals(dataList[i].TriggerSeName, triggerSeName, StringComparison.Ordinal))
				{
					data = dataList[i];
					return true;
				}
			}
			return false;
		}

		public static bool HasAnyActive(Player player)
		{
			if (TryGetUIData(player, out var dataList))
			{
				return dataList.Count > 0;
			}
			return false;
		}

		public static bool HasAnyRecharging(Player player)
		{
			if (!TryGetUIData(player, out var dataList))
			{
				return false;
			}
			foreach (ShieldAutoRechargeUIData item in dataList)
			{
				if (item.IsRecharging)
				{
					return true;
				}
			}
			return false;
		}
	}
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	public static class CustomSlotSystem
	{
		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
		public sealed class CustomSlotDefinition
		{
			public string SlotId;

			public string PlayerSaveKey;

			public Func<ItemData, bool> IsValid;

			public int VisualItemZdoKey => StringExtensionMethods.GetStableHashCode("DO_CustomSlotVisual_" + SlotId);

			public int VisualVariantZdoKey => StringExtensionMethods.GetStableHashCode("DO_CustomSlotVisualVariant_" + SlotId);
		}

		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		public sealed class HumanoidCustomSlotData
		{
			[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(1)]
			public readonly Dictionary<string, ItemData> EquippedItems = new Dictionary<string, ItemData>();
		}

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
		public sealed class VisCustomSlotState
		{
			public string ItemName = "";

			public int ItemHash;

			public int Variant;

			public List<GameObject> Instances;
		}

		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		public sealed class VisCustomSlotData
		{
			[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(1)]
			public readonly Dictionary<string, VisCustomSlotState> States = new Dictionary<string, VisCustomSlotState>();
		}

		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		private struct EquipPatchState
		{
			public bool Intercepted;

			[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(1)]
			public CustomSlotDefinition Definition;

			public ItemType OriginalType;
		}

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
		[HarmonyPatch(typeof(Humanoid), "EquipItem")]
		private static class Humanoid_EquipItem_CustomSlots
		{
			private static void Prefix(Humanoid __instance, ItemData item, bool triggerEquipEffects, ref EquipPatchState __state)
			{
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_007d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0082: Unknown result type (might be due to invalid IL or missing references)
				//IL_008d: Unknown result type (might be due to invalid IL or missing references)
				__state = default(EquipPatchState);
				EnsureDefinitionsInitialized();
				if (!IsSystemOwner() || !IsValidPlayer(__instance) || item == null)
				{
					return;
				}
				CustomSlotDefinition matchingSlotDefinition = GetMatchingSlotDefinition(item);
				if (matchingSlotDefinition == null)
				{
					return;
				}
				__state.Intercepted = true;
				__state.Definition = matchingSlotDefinition;
				__state.OriginalType = item.m_shared.m_itemType;
				item.m_shared.m_itemType = (ItemType)727;
				SharedData shared = item.m_shared;
				if (shared != null)
				{
					EffectList equipEffect = shared.m_equipEffect;
					if (equipEffect != null)
					{
						equipEffect.Create(((Component)__instance).transform.position + Vector3.up, ((Component)__instance).transform.rotation, (Transform)null, 1f, -1);
					}
				}
				Log("EquipItem Prefix intercepted custom slot '" + matchingSlotDefinition.SlotId + "' for item: " + GetSafeItemName(item));
			}

			[HarmonyPriority(800)]
			private static void Postfix(Humanoid __instance, ItemData item, bool triggerEquipEffects, ref bool __result, EquipPatchState __state)
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				EnsureDefinitionsInitialized();
				if (IsSystemOwner() && __state.Intercepted && IsValidPlayer(__instance) && item != null && __state.Definition != null)
				{
					item.m_shared.m_itemType = __state.OriginalType;
					EquipSlotInternal(__instance, __state.Definition, item, triggerEquipEffects);
					__result = true;
					Log("EquipItem Postfix equipped custom slot '" + __state.Definition.SlotId + "' for item: " + GetSafeItemName(item));
				}
			}
		}

		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		[HarmonyPatch(typeof(Humanoid), "UnequipItem")]
		private static class Humanoid_UnequipItem_CustomSlots
		{
			[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
			private static bool Prefix(Humanoid __instance, ItemData item, bool triggerEquipEffects = true)
			{
				EnsureDefinitionsInitialized();
				if (!IsSystemOwner())
				{
					return true;
				}
				if (!IsValidPlayer(__instance))
				{
					return true;
				}
				if (item == null)
				{
					return true;
				}
				KeyValuePair<string, ItemData>[] array = GetRuntimeData(__instance).EquippedItems.ToArray();
				for (int i = 0; i < array.Length; i++)
				{
					KeyValuePair<string, ItemData> keyValuePair = array[i];
					if (keyValuePair.Value == item)
					{
						CustomSlotDefinition definitionBySlotId = GetDefinitionBySlotId(keyValuePair.Key);
						if (definitionBySlotId == null)
						{
							return true;
						}
						UnequipSlotInternal(__instance, definitionBySlotId, item, triggerEquipEffects);
						return false;
					}
				}
				return true;
			}
		}

		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		[HarmonyPatch(typeof(Humanoid), "IsItemEquiped")]
		private static class Humanoid_IsItemEquiped_CustomSlots
		{
			[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
			private static void Postfix(Humanoid __instance, ItemData item, ref bool __result)
			{
				EnsureDefinitionsInitialized();
				if (IsSystemOwner() && IsValidPlayer(__instance) && !__result)
				{
					__result = IsItemEquippedInCustomSlot(__instance, item);
				}
			}
		}

		[HarmonyPatch(typeof(Player), "UnequipDeathDropItems")]
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		private static class Player_UnequipDeathDropItems_CustomSlots
		{
			[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
			private static void Prefix(Player __instance)
			{
				EnsureDefinitionsInitialized();
				if (IsSystemOwner() && !((Object)(object)__instance == (Object)null))
				{
					Log("Handling custom slot cleanup on death.");
					UnequipAllCustomSlots(__instance, triggerEquipEffects: false);
				}
			}
		}

		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		[HarmonyPatch(typeof(Inventory), "MoveInventoryToGrave")]
		private static class Inventory_MoveInventoryToGrave_CustomSlots
		{
			[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
			private static void Prefix(Inventory __instance, Inventory original)
			{
				EnsureDefinitionsInitialized();
				if (IsSystemOwner())
				{
					Player localPlayer = Player.m_localPlayer;
					if (!((Object)(object)localPlayer == (Object)null) && original != null && original == ((Humanoid)localPlayer).GetInventory())
					{
						Log("Preparing custom slot items for tombstone transfer.");
						UnequipAllCustomSlots(localPlayer, triggerEquipEffects: false);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Player), "OnInventoryChanged")]
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		private static class Player_OnInventoryChanged_CustomSlots
		{
			[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
			private static void Postfix(Player __instance)
			{
				EnsureDefinitionsInitialized();
				if (IsSystemOwner() && !((Object)(object)__instance == (Object)null) && !__instance.m_isLoading)
				{
					RestoreOrValidateCustomSlots(__instance);
				}
			}
		}

		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		[HarmonyPatch(typeof(Player), "OnSpawned")]
		private static class Player_OnSpawned_CustomSlots
		{
			[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
			private static void Postfix(Player __instance, bool spawnValkyrie)
			{
				EnsureDefinitionsInitialized();
				if (IsSystemOwner() && !((Object)(object)__instance == (Object)null))
				{
					RestoreOrValidateCustomSlots(__instance);
				}
			}
		}

		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		[HarmonyPatch(typeof(Humanoid), "SetupVisEquipment")]
		private static class Humanoid_SetupVisEquipment_CustomSlots
		{
			[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
			private static void Postfix(Humanoid __instance, VisEquipment visEq, bool isRagdoll)
			{
				if ((Object)(object)visEq == (Object)null)
				{
					return;
				}
				EnsureDefinitionsInitialized();
				if (!IsSystemOwner())
				{
					return;
				}
				for (int i = 0; i < SlotDefinitions.Count; i++)
				{
					CustomSlotDefinition customSlotDefinition = SlotDefinitions[i];
					ItemData equippedItem = GetEquippedItem(__instance, customSlotDefinition.SlotId);
					string itemName = "";
					int variant = 0;
					if (equippedItem != null && (Object)(object)equippedItem.m_dropPrefab != (Object)null)
					{
						itemName = ((Object)equippedItem.m_dropPrefab).name;
						variant = equippedItem.m_variant;
					}
					SetCustomVisualState(visEq, customSlotDefinition, itemName, variant);
				}
			}
		}

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
		[HarmonyPatch(typeof(VisEquipment), "UpdateEquipmentVisuals")]
		private static class VisEquipment_UpdateEquipmentVisuals_CustomSlots
		{
			internal static VisEquipment _currentVisEquipment;

			internal static bool _updateLodGroup;

			private static void Prefix(VisEquipment __instance)
			{
				EnsureDefinitionsInitialized();
				if (!IsSystemOwner())
				{
					return;
				}
				_currentVisEquipment = __instance;
				_updateLodGroup = false;
				ZNetView visNView = GetVisNView(__instance);
				ZDO val = (((Object)(object)visNView != (Object)null) ? visNView.GetZDO() : null);
				for (int i = 0; i < SlotDefinitions.Count; i++)
				{
					CustomSlotDefinition customSlotDefinition = SlotDefinitions[i];
					int itemHash = 0;
					int num = 0;
					if (val != null)
					{
						itemHash = val.GetInt(customSlotDefinition.VisualItemZdoKey, 0);
						num = val.GetInt(customSlotDefinition.VisualVariantZdoKey, 0);
					}
					else
					{
						VisCustomSlotState visualState = GetVisualState(__instance, customSlotDefinition.SlotId);
						if (!string.IsNullOrEmpty(visualState.ItemName))
						{
							itemHash = StringExtensionMethods.GetStableHashCode(visualState.ItemName);
						}
						num = visualState.Variant;
					}
					if (SetCustomVisualEquipped(__instance, customSlotDefinition, itemHash, num))
					{
						_updateLodGroup = true;
					}
				}
			}

			private static void Postfix(VisEquipment __instance)
			{
				if (IsSystemOwner())
				{
					if (_updateLodGroup)
					{
						CallUpdateLodgroup(__instance);
					}
					_currentVisEquipment = null;
					_updateLodGroup = false;
				}
			}
		}

		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		[HarmonyPatch(typeof(VisEquipment), "UpdateLodgroup")]
		private static class VisEquipment_UpdateLodgroup_CustomSlots
		{
			[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
			private static void Finalizer(VisEquipment __instance)
			{
				if (IsSystemOwner() && (Object)(object)__instance == (Object)(object)VisEquipment_UpdateEquipmentVisuals_CustomSlots._currentVisEquipment)
				{
					VisEquipment_UpdateEquipmentVisuals_CustomSlots._updateLodGroup = false;
				}
			}
		}

		private const bool EnableCustomSlotDebugLogs = false;

		private const string LocalSystemId = "Magic_Supremacy";

		private const string SharedOwnerKey = "DO_CustomSlotSystem_Owner";

		private const string SharedBeltRegistryKey = "DO_CustomSlotSystem_BeltPrefabs";

		private const string GenericItemGuidKey = "DO_CustomSlotGuid";

		private const int FakeCustomSlotItemType = 727;

		private static readonly MethodInfo SetupEquipmentMethod = AccessTools.Method(typeof(Humanoid), "SetupEquipment", (Type[])null, (Type[])null);

		private static readonly MethodInfo TriggerEquipEffectMethod = AccessTools.Method(typeof(Humanoid), "TriggerEquipEffect", new Type[1] { typeof(ItemData) }, (Type[])null);

		private static readonly MethodInfo HaveStatusEffectMethod = AccessTools.Method(typeof(SEMan), "HaveStatusEffect", new Type[1] { typeof(int) }, (Type[])null);

		private static readonly MethodInfo GetStatusEffectMethod = AccessTools.Method(typeof(SEMan), "GetStatusEffect", new Type[1] { typeof(int) }, (Type[])null);

		private static readonly MethodInfo VisAttachArmorMethod = AccessTools.Method(typeof(VisEquipment), "AttachArmor", new Type[2]
		{
			typeof(int),
			typeof(int)
		}, (Type[])null);

		private static readonly MethodInfo VisUpdateLodgroupMethod = AccessTools.Method(typeof(VisEquipment), "UpdateLodgroup", (Type[])null, (Type[])null);

		private static readonly FieldInfo VisNViewField = AccessTools.Field(typeof(VisEquipment), "m_nview");

		private static readonly FieldInfo VisLodGroupField = AccessTools.Field(typeof(VisEquipment), "m_lodGroup");

		private static readonly ConditionalWeakTable<Humanoid, HumanoidCustomSlotData> RuntimeData = new ConditionalWeakTable<Humanoid, HumanoidCustomSlotData>();

		private static readonly List<CustomSlotDefinition> SlotDefinitions = new List<CustomSlotDefinition>();

		private static bool _definitionsInitialized;

		private static readonly ConditionalWeakTable<VisEquipment, VisCustomSlotData> VisualRuntimeData = new ConditionalWeakTable<VisEquipment, VisCustomSlotData>();

		private static readonly HashSet<string> BeltPrefabNames = new HashSet<string> { "ArmorMushroomcallerBeltDO", "ArmorDeathcallerBeltDO", "ArmorFrostcallerBeltDO", "ArmorFirecallerBeltDO", "ArmorStonecallerBeltDO", "ArmorLightcallerBeltDO", "ArmorStormcallerBeltDO" };

		private static void Log(string msg)
		{
		}

		private static void LogWarning(string msg)
		{
		}

		private static HashSet<string> GetSharedBeltRegistry()
		{
			if (AppDomain.CurrentDomain.GetData("DO_CustomSlotSystem_BeltPrefabs") is HashSet<string> result)
			{
				return result;
			}
			HashSet<string> hashSet = new HashSet<string>();
			AppDomain.CurrentDomain.SetData("DO_CustomSlotSystem_BeltPrefabs", hashSet);
			return hashSet;
		}

		private static void RegisterLocalBeltPrefabsIntoSharedRegistry()
		{
			HashSet<string> sharedBeltRegistry = GetSharedBeltRegistry();
			foreach (string beltPrefabName in BeltPrefabNames)
			{
				if (!string.IsNullOrWhiteSpace(beltPrefabName))
				{
					sharedBeltRegistry.Add(beltPrefabName);
				}
			}
			Log($"Registered local belt prefabs into shared registry. Local={BeltPrefabNames.Count}, Shared={sharedBeltRegistry.Count}");
		}

		private static void TryClaimSystemOwner()
		{
			if (AppDomain.CurrentDomain.GetData("DO_CustomSlotSystem_Owner") is string text && !string.IsNullOrWhiteSpace(text))
			{
				Log("CustomSlotSystem owner already exists: " + text + ". Local system is follower: Magic_Supremacy");
				return;
			}
			AppDomain.CurrentDomain.SetData("DO_CustomSlotSystem_Owner", "Magic_Supremacy");
			Log("CustomSlotSystem owner claimed by: Magic_Supremacy");
		}

		private static bool IsSystemOwner()
		{
			if (AppDomain.CurrentDomain.GetData("DO_CustomSlotSystem_Owner") is string text)
			{
				return text == "Magic_Supremacy";
			}
			return false;
		}

		private static void EnsureDefinitionsInitialized()
		{
			if (!_definitionsInitialized)
			{
				_definitionsInitialized = true;
				RegisterLocalBeltPrefabsIntoSharedRegistry();
				TryClaimSystemOwner();
				SlotDefinitions.Add(new CustomSlotDefinition
				{
					SlotId = "belt",
					PlayerSaveKey = "DO_Equipped_belt",
					IsValid = IsBeltItem
				});
				Log("Custom slot definitions initialized. Registered slots: " + string.Join(", ", SlotDefinitions.Select([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (CustomSlotDefinition x) => x.SlotId)));
			}
		}

		public static void Initialize()
		{
			EnsureDefinitionsInitialized();
		}

		private static bool IsValidPlayer(Humanoid humanoid)
		{
			Player val = (Player)(object)((humanoid is Player) ? humanoid : null);
			if (val != null && (Object)(object)val != (Object)null)
			{
				return ((Humanoid)val).GetInventory() != null;
			}
			return false;
		}

		private static HumanoidCustomSlotData GetRuntimeData(Humanoid humanoid)
		{
			return RuntimeData.GetOrCreateValue(humanoid);
		}

		private static VisCustomSlotData GetVisualRuntimeData(VisEquipment visEquipment)
		{
			return VisualRuntimeData.GetOrCreateValue(visEquipment);
		}

		private static VisCustomSlotState GetVisualState(VisEquipment visEquipment, string slotId)
		{
			VisCustomSlotData visualRuntimeData = GetVisualRuntimeData(visEquipment);
			if (!visualRuntimeData.States.TryGetValue(slotId, out var value))
			{
				value = new VisCustomSlotState();
				visualRuntimeData.States[slotId] = value;
			}
			return value;
		}

		private static bool IsBeltItem(ItemData item)
		{
			if (item == null || (Object)(object)item.m_dropPrefab == (Object)null)
			{
				return false;
			}
			return GetSharedBeltRegistry().Contains(((Object)item.m_dropPrefab).name);
		}

		public static CustomSlotDefinition GetMatchingSlotDefinition(ItemData item)
		{
			EnsureDefinitionsInitialized();
			if (item == null)
			{
				return null;
			}
			for (int i = 0; i < SlotDefinitions.Count; i++)
			{
				if (SlotDefinitions[i].IsValid(item))
				{
					return SlotDefinitions[i];
				}
			}
			return null;
		}

		private static CustomSlotDefinition GetDefinitionBySlotId(string slotId)
		{
			EnsureDefinitionsInitialized();
			for (int i = 0; i < SlotDefinitions.Count; i++)
			{
				if (SlotDefinitions[i].SlotId == slotId)
				{
					return SlotDefinitions[i];
				}
			}
			return null;
		}

		public static bool IsCustomSlotItem(ItemData item)
		{
			return GetMatchingSlotDefinition(item) != null;
		}

		public static ItemData GetEquippedItem(Humanoid humanoid, string slotId)
		{
			if ((Object)(object)humanoid == (Object)null || string.IsNullOrEmpty(slotId))
			{
				return null;
			}
			if (!GetRuntimeData(humanoid).EquippedItems.TryGetValue(slotId, out var value))
			{
				return null;
			}
			return value;
		}

		public static void SetEquippedItem(Humanoid humanoid, string slotId, ItemData item)
		{
			if (!((Object)(object)humanoid == (Object)null) && !string.IsNullOrEmpty(slotId))
			{
				HumanoidCustomSlotData runtimeData = GetRuntimeData(humanoid);
				if (item == null)
				{
					runtimeData.EquippedItems.Remove(slotId);
				}
				else
				{
					runtimeData.EquippedItems[slotId] = item;
				}
			}
		}

		public static bool IsItemEquippedInCustomSlot(Humanoid humanoid, ItemData item)
		{
			if ((Object)(object)humanoid == (Object)null || item == null)
			{
				return false;
			}
			foreach (KeyValuePair<string, ItemData> equippedItem in GetRuntimeData(humanoid).EquippedItems)
			{
				if (equippedItem.Value == item)
				{
					return true;
				}
			}
			return false;
		}

		private static void RefreshEquipment(Humanoid humanoid)
		{
			if (!((Object)(object)humanoid == (Object)null))
			{
				SetupEquipmentMethod?.Invoke(humanoid, null);
			}
		}

		private static void TriggerEquipRefresh(Humanoid humanoid, ItemData item)
		{
			if (!((Object)(object)humanoid == (Object)null) && item != null)
			{
				TriggerEquipEffectMethod?.Invoke(humanoid, new object[1] { item });
			}
		}

		private static ZNetView GetVisNView(VisEquipment visEquipment)
		{
			object? obj = VisNViewField?.GetValue(visEquipment);
			return (ZNetView)((obj is ZNetView) ? obj : null);
		}

		private static LODGroup GetVisLodGroup(VisEquipment visEquipment)
		{
			object? obj = VisLodGroupField?.GetValue(visEquipment);
			return (LODGroup)((obj is LODGroup) ? obj : null);
		}

		private static List<GameObject> CallAttachArmor(VisEquipment visEquipment, int itemHash, int variant)
		{
			if ((Object)(object)visEquipment == (Object)null || VisAttachArmorMethod == null || itemHash == 0)
			{
				return null;
			}
			return VisAttachArmorMethod.Invoke(visEquipment, new object[2] { itemHash, variant }) as List<GameObject>;
		}

		private static void CallUpdateLodgroup(VisEquipment visEquipment)
		{
			if (!((Object)(object)visEquipment == (Object)null) && !(VisUpdateLodgroupMethod == null))
			{
				VisUpdateLodgroupMethod.Invoke(visEquipment, null);
			}
		}

		private static string GetItemGuid(ItemData item)
		{
			if (item == null || item.m_customData == null)
			{
				return null;
			}
			if (!item.m_customData.TryGetValue("DO_CustomSlotGuid", out var value))
			{
				return null;
			}
			return value;
		}

		private static string GetOrCreateItemGuid(ItemData item)
		{
			if (item == null)
			{
				return null;
			}
			if (item.m_customData == null)
			{
				item.m_customData = new Dictionary<string, string>();
			}
			if (!item.m_customData.TryGetValue("DO_CustomSlotGuid", out var value) || string.IsNullOrWhiteSpace(value))
			{
				value = Guid.NewGuid().ToString("N");
				item.m_customData["DO_CustomSlotGuid"] = value;
				Log("Generated new item GUID for " + GetSafeItemName(item) + ": " + value);
			}
			return value;
		}

		private static string GetSavedEquippedGuid(Player player, CustomSlotDefinition definition)
		{
			if ((Object)(object)player == (Object)null || definition == null || player.m_customData == null)
			{
				return null;
			}
			if (!player.m_customData.TryGetValue(definition.PlayerSaveKey, out var value))
			{
				return null;
			}
			return value;
		}

		private static void SetSavedEquippedGuid(Player player, CustomSlotDefinition definition, string guid)
		{
			if (!((Object)(object)player == (Object)null) && definition != null)
			{
				if (player.m_customData == null)
				{
					player.m_customData = new Dictionary<string, string>();
				}
				player.m_customData[definition.PlayerSaveKey] = guid;
				Log("Saved equipped GUID for slot '" + definition.SlotId + "': " + guid);
			}
		}

		private static void ClearSavedEquippedGuid(Player player, CustomSlotDefinition definition)
		{
			if (!((Object)(object)player == (Object)null) && definition != null && player.m_customData != null && player.m_customData.Remove(definition.PlayerSaveKey))
			{
				Log("Cleared saved equipped GUID for slot '" + definition.SlotId + "'");
			}
		}

		private static ItemData FindInventoryItemByGuid(Player player, string guid, CustomSlotDefinition definition)
		{
			if ((Object)(object)player == (Object)null || string.IsNullOrWhiteSpace(guid) || definition == null)
			{
				return null;
			}
			List<ItemData> allItems = ((Humanoid)player).GetInventory().GetAllItems();
			for (int i = 0; i < allItems.Count; i++)
			{
				ItemData val = allItems[i];
				if (val != null && definition.IsValid(val) && GetItemGuid(val) == guid)
				{
					return val;
				}
			}
			return null;
		}

		private static string GetSafeItemName(ItemData item)
		{
			if (item == null)
			{
				return "<null item>";
			}
			if (!string.IsNullOrEmpty(item.m_shared?.m_name))
			{
				return item.m_shared.m_name;
			}
			if ((Object)(object)item.m_dropPrefab != (Object)null)
			{
				return ((Object)item.m_dropPrefab).name;
			}
			return "<unnamed item>";
		}

		private static bool HasStatusEffect(SEMan seman, int nameHash)
		{
			if (seman == null || nameHash == 0)
			{
				return false;
			}
			if (HaveStatusEffectMethod != null)
			{
				object obj = HaveStatusEffectMethod.Invoke(seman, new object[1] { nameHash });
				if (obj is bool)
				{
					return (bool)obj;
				}
			}
			if (GetStatusEffectMethod != null)
			{
				return GetStatusEffectMethod.Invoke(seman, new object[1] { nameHash }) != null;
			}
			return false;
		}

		private static void ApplyStatusEffect(Humanoid humanoid, ItemData item)
		{
			if ((Object)(object)humanoid == (Object)null || item == null)
			{
				return;
			}
			StatusEffect val = item.m_shared?.m_equipStatusEffect;
			if (!Object.op_Implicit((Object)(object)val))
			{
				return;
			}
			SEMan sEMan = ((Character)humanoid).GetSEMan();
			if (sEMan != null)
			{
				int nameHash = val.NameHash();
				if (!HasStatusEffect(sEMan, nameHash))
				{
					sEMan.AddStatusEffect(val, false, 0, 0f);
					Log("Applied status effect '" + ((Object)val).name + "' from " + GetSafeItemName(item));
				}
			}
		}

		private static void RemoveStatusEffect(Humanoid humanoid, ItemData item)
		{
			if ((Object)(object)humanoid == (Object)null || item == null)
			{
				return;
			}
			StatusEffect val = item.m_shared?.m_equipStatusEffect;
			if (!Object.op_Implicit((Object)(object)val))
			{
				return;
			}
			SEMan sEMan = ((Character)humanoid).GetSEMan();
			if (sEMan != null)
			{
				int num = val.NameHash();
				if (num != 0)
				{
					sEMan.RemoveStatusEffect(num, false);
					Log("Removed status effect '" + ((Object)val).name + "' from " + GetSafeItemName(item));
				}
			}
		}

		private static void SetCustomVisualState(VisEquipment visEquipment, CustomSlotDefinition definition, string itemName, int variant)
		{
			if ((Object)(object)visEquipment == (Object)null || definition == null)
			{
				return;
			}
			VisCustomSlotState visualState = GetVisualState(visEquipment, definition.SlotId);
			if (visualState.ItemName == itemName && visualState.Variant == variant)
			{
				return;
			}
			visualState.ItemName = itemName ?? "";
			visualState.Variant = variant;
			ZNetView visNView = GetVisNView(visEquipment);
			if ((Object)(object)visNView != (Object)null && visNView.IsValid() && visNView.IsOwner())
			{
				ZDO zDO = visNView.GetZDO();
				if (zDO != null)
				{
					int num = ((!string.IsNullOrEmpty(itemName)) ? StringExtensionMethods.GetStableHashCode(itemName) : 0);
					zDO.Set(definition.VisualItemZdoKey, num, false);
					zDO.Set(definition.VisualVariantZdoKey, variant, false);
				}
			}
		}

		private static bool SetCustomVisualEquipped(VisEquipment visEquipment, CustomSlotDefinition definition, int itemHash, int variant)
		{
			if ((Object)(object)visEquipment == (Object)null || definition == null)
			{
				return false;
			}
			VisCustomSlotState visualState = GetVisualState(visEquipment, definition.SlotId);
			if (visualState.ItemHash == itemHash && visualState.Variant == variant)
			{
				return false;
			}
			if (visualState.Instances != null)
			{
				LODGroup visLodGroup = GetVisLodGroup(visEquipment);
				for (int i = 0; i < visualState.Instances.Count; i++)
				{
					GameObject val = visualState.Instances[i];
					if (!((Object)(object)val == (Object)null))
					{
						if ((Object)(object)visLodGroup != (Object)null)
						{
							Utils.RemoveFromLodgroup(visLodGroup, val);
						}
						Object.Destroy((Object)(object)val);
					}
				}
				visualState.Instances = null;
			}
			visualState.ItemHash = itemHash;
			visualState.Variant = variant;
			if (itemHash != 0)
			{
				visualState.Instances = CallAttachArmor(visEquipment, itemHash, variant);
			}
			return true;
		}

		private static void UnequipSlotInternal(Humanoid humanoid, CustomSlotDefinition definition, ItemData item, bool triggerEquipEffects)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)humanoid == (Object)null || definition == null || item == null)
			{
				return;
			}
			RemoveStatusEffect(humanoid, item);
			item.m_equipped = false;
			SetEquippedItem(humanoid, definition.SlotId, null);
			Player val = (Player)(object)((humanoid is Player) ? humanoid : null);
			if (val != null)
			{
				ClearSavedEquippedGuid(val, definition);
			}
			SharedData shared = item.m_shared;
			if (shared != null)
			{
				EffectList unequipEffect = shared.m_unequipEffect;
				if (unequipEffect != null)
				{
					unequipEffect.Create(((Component)humanoid).transform.position, Quaternion.identity, (Transform)null, 1f, -1);
				}
			}
			RefreshEquipment(humanoid);
			if (triggerEquipEffects)
			{
				TriggerEquipRefresh(humanoid, item);
			}
			Log("Unequipped custom slot '" + definition.SlotId + "' item: " + GetSafeItemName(item));
		}

		private static void EquipSlotInternal(Humanoid humanoid, CustomSlotDefinition definition, ItemData item, bool triggerEquipEffects)
		{
			if ((Object)(object)humanoid == (Object)null || definition == null || item == null)
			{
				return;
			}
			ItemData equippedItem = GetEquippedItem(humanoid, definition.SlotId);
			if (equippedItem == item)
			{
				Log("Equip ignored: item already equipped in slot '" + definition.SlotId + "': " + GetSafeItemName(item));
				return;
			}
			if (equippedItem != null)
			{
				UnequipSlotInternal(humanoid, definition, equippedItem, triggerEquipEffects);
			}
			SetEquippedItem(humanoid, definition.SlotId, item);
			item.m_equipped = true;
			Player val = (Player)(object)((humanoid is Player) ? humanoid : null);
			if (val != null)
			{
				string orCreateItemGuid = GetOrCreateItemGuid(item);
				SetSavedEquippedGuid(val, definition, orCreateItemGuid);
			}
			ApplyStatusEffect(humanoid, item);
			RefreshEquipment(humanoid);
			Log("Equipped custom slot '" + definition.SlotId + "' item: " + GetSafeItemName(item));
		}

		private static void UnequipAllCustomSlots(Player player, bool triggerEquipEffects)
		{
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			EnsureDefinitionsInitialized();
			for (int i = 0; i < SlotDefinitions.Count; i++)
			{
				CustomSlotDefinition customSlotDefinition = SlotDefinitions[i];
				ItemData equippedItem = GetEquippedItem((Humanoid)(object)player, customSlotDefinition.SlotId);
				if (equippedItem != null)
				{
					UnequipSlotInternal((Humanoid)(object)player, customSlotDefinition, equippedItem, triggerEquipEffects);
				}
				else
				{
					ClearSavedEquippedGuid(player, customSlotDefinition);
				}
			}
		}

		public static void RestoreOrValidateCustomSlots(Player player)
		{
			if (!((Object)(object)player == (Object)null))
			{
				EnsureDefinitionsInitialized();
				for (int i = 0; i < SlotDefinitions.Count; i++)
				{
					ValidateSingleSlot(player, SlotDefinitions[i]);
				}
			}
		}

		private static void ValidateSingleSlot(Player player, CustomSlotDefinition definition)
		{
			if ((Object)(object)player == (Object)null || definition == null)
			{
				return;
			}
			ItemData equippedItem = GetEquippedItem((Humanoid)(object)player, definition.SlotId);
			string savedEquippedGuid = GetSavedEquippedGuid(player, definition);
			if (string.IsNullOrWhiteSpace(savedEquippedGuid))
			{
				if (equippedItem != null)
				{
					LogWarning("Slot '" + definition.SlotId + "' had runtime item but no saved GUID. Cleaning up.");
					UnequipSlotInternal((Humanoid)(object)player, definition, equippedItem, triggerEquipEffects: false);
				}
				return;
			}
			ItemData val = FindInventoryItemByGuid(player, savedEquippedGuid, definition);
			if (val == null)
			{
				LogWarning("Saved custom slot item for slot '" + definition.SlotId + "' was not found in inventory. Cleaning up saved state.");
				if (equippedItem != null)
				{
					RemoveStatusEffect((Humanoid)(object)player, equippedItem);
					equippedItem.m_equipped = false;
				}
				SetEquippedItem((Humanoid)(object)player, definition.SlotId, null);
				ClearSavedEquippedGuid(player, definition);
				RefreshEquipment((Humanoid)(object)player);
				return;
			}
			if (equippedItem != null && equippedItem != val)
			{
				LogWarning("Runtime item and saved item differed for slot '" + definition.SlotId + "'. Replacing runtime state.");
				RemoveStatusEffect((Humanoid)(object)player, equippedItem);
				equippedItem.m_equipped = false;
			}
			SetEquippedItem((Humanoid)(object)player, definition.SlotId, val);
			val.m_equipped = true;
			ApplyStatusEffect((Humanoid)(object)player, val);
			RefreshEquipment((Humanoid)(object)player);
			Log("Validated slot '" + definition.SlotId + "' with item: " + GetSafeItemName(val));
		}
	}
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	public static class InspirationSystem
	{
		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
		public sealed class InspirationController : MonoBehaviour
		{
			private Player _player;

			private float _currentProgress;

			private int _currentPoints;

			private int _currentMaxPoints;

			private bool _isActive;

			private float _lastLoggedGainPercent = float.MinValue;

			private int _lastLoggedMaxPoints = int.MinValue;

			private string _lastLoggedActiveSourcesKey = string.Empty;

			private float _suppressNotEnoughMessageUntil;

			private bool _lastSpendWasSecondary;

			private int _lastSpendCost;

			private string _lastSpendWeaponPrefabName = string.Empty;

			public void Setup(Player player)
			{
				_player = player;
				_currentProgress = 0f;
				_currentPoints = 0;
				_currentMaxPoints = GetBaseMaxPoints();
				_isActive = false;
			}

			public void ManualUpdate(float dt)
			{
				if ((Object)(object)_player == (Object)null)
				{
					_player = ((Component)this).GetComponent<Player>();
					if ((Object)(object)_player == (Object)null)
					{
						return;
					}
				}
				if (!IsSystemEnabled())
				{
					if (_isActive || _currentProgress > 0f || _currentPoints > 0)
					{
						Log("Inspiration system globally disabled. Resetting state.");
					}
					RemoveVisualStatusEffect();
					ResetState();
					return;
				}
				List<InspirationSourceDef> list = CollectActiveSources();
				bool flag = false;
				for (int i = 0; i < list.Count; i++)
				{
					if (list[i].ActivatesInspiration)
					{
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					if (_isActive)
					{
						Log("Inspiration system deactivated. Progress and points reset.");
					}
					RemoveVisualStatusEffect();
					ResetState();
					return;
				}
				if (!_isActive)
				{
					Log("Inspiration system activated.");
				}
				_isActive = true;
				float num = 0f;
				int num2 = 0;
				for (int j = 0; j < list.Count; j++)
				{
					num += list[j].InspirationGainPercentBonus;
					num2 += list[j].MaxInspirationBonus;
				}
				int num3 = GetBaseMaxPoints() + num2;
				_currentMaxPoints = Mathf.Clamp(num3, 0, 8);
				if (_currentPoints > _currentMaxPoints)
				{
					Log($"Current points {_currentPoints} exceed new max {_currentMaxPoints}. Clamping.");
					_currentPoints = _currentMaxPoints;
				}
				string text = string.Join(" | ", list.ConvertAll<string>(GetSourceDisplayName));
				if (!Mathf.Approximately(_lastLoggedGainPercent, num) || _lastLoggedMaxPoints != _currentMaxPoints || !string.Equals(_lastLoggedActiveSourcesKey, text, StringComparison.Ordinal))
				{
					_lastLoggedGainPercent = num;
					_lastLoggedMaxPoints = _currentMaxPoints;
					_lastLoggedActiveSourcesKey = text;
					Log("Active sources: " + text);
					Log($"Gain bonus total: {num:0.##}%, Final max inspiration: {_currentMaxPoints}");
				}
				TickProgress(dt, num);
				RefreshVisualStatusEffect();
			}

			private List<InspirationSourceDef> CollectActiveSources()
			{
				List<InspirationSourceDef> list = new List<InspirationSourceDef>();
				for (int i = 0; i < InspirationSourceDefs.Count; i++)
				{
					InspirationSourceDef inspirationSourceDef = InspirationSourceDefs[i];
					if (HasSource(inspirationSourceDef))
					{
						list.Add(inspirationSourceDef);
					}
				}
				return list;
			}

			private bool HasSource(InspirationSourceDef def)
			{
				return def.SourceType switch
				{
					InspirationSourceType.Item => HasItemSource(def.SourceName), 
					InspirationSourceType.StatusEffect => HasStatusEffectSource(def.SourceName), 
					_ => false, 
				};
			}

			private bool HasItemSource(string prefabName)
			{
				if ((Object)(object)_player == (Object)null)
				{
					return false;
				}
				List<ItemData> allItems = ((Humanoid)_player).GetInventory().GetAllItems();
				for (int i = 0; i < allItems.Count; i++)
				{
					ItemData val = allItems[i];
					if (val.m_equipped && string.Equals(GetItemPrefabName(val), prefabName, StringComparison.Ordinal))
					{
						return true;
					}
				}
				return false;
			}

			private bool HasStatusEffectSource(string seName)
			{
				if ((Object)(object)_player == (Object)null || ((Character)_player).GetSEMan() == null || string.IsNullOrEmpty(seName))
				{
					return false;
				}
				return ((Character)_player).GetSEMan().HaveStatusEffect(StringExtensionMethods.GetStableHashCode(seName));
			}

			private void TickProgress(float dt, float totalGainPercent)
			{
				if (_currentMaxPoints <= 0)
				{
					if (_currentProgress != 0f || _currentPoints != 0)
					{
						Log("Current max inspiration is 0. Resetting progress and points.");
					}
					_currentProgress = 0f;
					_currentPoints = 0;
					return;
				}
				if (_currentPoints >= _currentMaxPoints)
				{
					if (_currentProgress != 0f)
					{
						Log($"At max inspiration ({_currentPoints}/{_currentMaxPoints}), resetting progress to 0.");
					}
					_currentProgress = 0f;
					return;
				}
				float num = GetBaseGainPerSecond() * (1f + totalGainPercent / 100f);
				if (num <= 0f)
				{
					return;
				}
				_currentProgress += num * dt;
				float progressPerPoint = GetProgressPerPoint();
				while (_currentProgress >= progressPerPoint)
				{
					_currentProgress -= progressPerPoint;
					if (_currentPoints < _currentMaxPoints)
					{
						_currentPoints++;
						OnPointGained();
						Log($"Gained inspiration point. Points={_currentPoints}/{_currentMaxPoints}, Progress={_currentProgress:0.##}");
						continue;
					}
					_currentProgress = 0f;
					Log($"Reached max inspiration while processing progress. Progress reset to 0. Points={_currentPoints}/{_currentMaxPoints}");
					break;
				}
				if (_currentPoints >= _currentMaxPoints)
				{
					_currentProgress = 0f;
				}
			}

			private void OnPointGained()
			{
				//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
				if (!IsPointGainFxEnabled() || string.IsNullOrWhiteSpace("sfx_inspiration_gain_DO") || (Object)(object)_player == (Object)null)
				{
					return;
				}
				GameObject val = (((Object)(object)ZNetScene.instance != (Object)null) ? ZNetScene.instance.GetPrefab("sfx_inspiration_gain_DO") : null);
				if ((Object)(object)val == (Object)null && (Object)(object)ObjectDB.instance != (Object)null)
				{
					val = ObjectDB.instance.GetItemPrefab("sfx_inspiration_gain_DO");
				}
				if ((Object)(object)val == (Object)null && (Object)(object)Magic_SupremacyPlugin.MainAssetBundle != (Object)null)
				{
					try
					{
						val = Magic_SupremacyPlugin.MainAssetBundle.LoadAsset<GameObject>("sfx_inspiration_gain_DO");
					}
					catch
					{
					}
				}
				if ((Object)(object)val == (Object)null)
				{
					Log("Point gain FX prefab not found: 'sfx_inspiration_gain_DO'.");
				}
				else
				{
					Object.Instantiate<GameObject>(val, ((Component)_player).transform.position, Quaternion.identity);
				}
			}

			private void RefreshVisualStatusEffect()
			{
				if ((Object)(object)_player == (Object)null)
				{
					return;
				}
				SEMan sEMan = ((Character)_player).GetSEMan();
				if (sEMan != null && !((Object)(object)_visualStatusEffect == (Object)null))
				{
					int visualStatusEffectNameHash = _visualStatusEffectNameHash;
					StatusEffect statusEffect = sEMan.GetStatusEffect(visualStatusEffectNameHash);
					if ((Object)(object)statusEffect == (Object)null)
					{
						sEMan.AddStatusEffect(_visualStatusEffect, true, 0, 0f);
						Log("Added visual SE_Inspiration_DO.");
					}
					else
					{
						statusEffect.ResetTime();
					}
				}
			}

			private void RemoveVisualStatusEffect()
			{
				if (!((Object)(object)_player == (Object)null))
				{
					SEMan sEMan = ((Character)_player).GetSEMan();
					if (sEMan != null && !((Object)(object)_visualStatusEffect == (Object)null) && sEMan.RemoveStatusEffect(_visualStatusEffectNameHash, true))
					{
						Log("Removed visual SE_Inspiration_DO.");
					}
				}
			}

			public bool CanSpend(int cost)
			{
				if (!_isActive)
				{
					return cost <= 0;
				}
				if (cost <= 0)
				{
					return true;
				}
				return _currentPoints >= cost;
			}

			public bool TrySpend(int cost, bool secondaryAttack, string weaponPrefabName)
			{
				if (!_isActive)
				{
					return cost <= 0;
				}
				if (cost <= 0)
				{
					return true;
				}
				if (_currentPoints < cost)
				{
					return false;
				}
				_currentPoints -= cost;
				_suppressNotEnoughMessageUntil = Time.time + 0.35f;
				_lastSpendWasSecondary = secondaryAttack;
				_lastSpendCost = cost;
				_lastSpendWeaponPrefabName = weaponPrefabName ?? string.Empty;
				RefreshVisualStatusEffect();
				return true;
			}

			public bool ShouldSuppressNotEnoughMessage(int cost, bool secondaryAttack, string weaponPrefabName)
			{
				if (Time.time > _suppressNotEnoughMessageUntil)
				{
					return false;
				}
				if (_lastSpendWasSecondary != secondaryAttack)
				{
					return false;
				}
				if (_lastSpendCost != cost)
				{
					return false;
				}
				if (!string.Equals(_lastSpendWeaponPrefabName, weaponPrefabName ?? string.Empty, StringComparison.Ordinal))
				{
					return false;
				}
				return true;
			}

			public void ResetState()
			{
				_currentProgress = 0f;
				_currentPoints = 0;
				_currentMaxPoints = GetBaseMaxPoints();
				_isActive = false;
				_lastLoggedGainPercent = float.MinValue;
				_lastLoggedMaxPoints = int.MinValue;
				_lastLoggedActiveSourcesKey = string.Empty;
				_suppressNotEnoughMessageUntil = 0f;
				_lastSpendWasSecondary = false;
				_lastSpendCost = 0;
				_lastSpendWeaponPrefabName = string.Empty;
			}

			public int GetCurrentPoints()
			{
				return _currentPoints;
			}

			public int GetCurrentMaxPoints()
			{
				return _currentMaxPoints;
			}

			public float GetCurrentProgress()
			{
				return _currentProgress;
			}

			public bool IsActive()
			{
				return _isActive;
			}
		}

		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		public struct InspirationUIData
		{
			public bool IsActive;

			public int CurrentPoints;

			public int MaxPoints;

			public float Progress;

			public float ProgressMax;

			public float ProgressNormalized;
		}

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
		public sealed class InspirationUsageDef
		{
			public string DisplayName;

			public string PrefabName;

			public bool PrimaryUsesInspiration;

			public bool SecondaryUsesInspiration;

			public int PrimaryInspirationCost;

			public int SecondaryInspirationCost;
		}

		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		public enum InspirationSourceType
		{
			Item,
			StatusEffect
		}

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
		public sealed class InspirationSourceDef
		{
			public string DisplayName;

			public string Name;

			public InspirationSourceType SourceType;

			public string SourceName;

			public bool ActivatesInspiration;

			public float InspirationGainPercentBonus;

			public int MaxInspirationBonus;
		}

		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		[HarmonyPatch(typeof(StatusEffect), "GetIconText")]
		private static class Inspiration_StatusEffect_GetIconText_Patch
		{
			[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
			private static void Postfix(StatusEffect __instance, ref string __result)
			{
				if (!_initialized || !IsSystemEnabled() || (Object)(object)__instance == (Object)null || __instance.NameHash() != _visualStatusEffectNameHash)
				{
					return;
				}
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					if (!TryGetController(localPlayer, out var controller) || !controller.IsActive())
					{
						__result = "";
					}
					else
					{
						__result = $"{controller.GetCurrentPoints()}/{controller.GetCurrentMaxPoints()}";
					}
				}
			}
		}

		[HarmonyPatch(typeof(StatusEffect), "GetTooltipString")]
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		private static class Inspiration_StatusEffect_GetTooltipString_Patch
		{
			[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
			private static void Postfix(StatusEffect __instance, ref string __result)
			{
				if (_initialized && IsSystemEnabled() && !((Object)(object)__instance == (Object)null) && __instance.NameHash() == _visualStatusEffectNameHash)
				{
					Player localPlayer = Player.m_localPlayer;
					if (localPlayer != null && TryGetController(localPlayer, out var controller) && controller.IsActive())
					{
						__result = Localization.instance.Localize("$se_inspiration_tooltip") + $"\n{controller.GetCurrentPoints()}/{controller.GetCurrentMaxPoints()}";
					}
				}
			}
		}

		[HarmonyPatch(typeof(Player), "Update")]
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		private static class Inspiration_PlayerUpdate_Patch
		{
			[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
			private static void Postfix(Player __instance)
			{
				if (_initialized && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
				{
					InspirationController orCreateController = GetOrCreateController(__instance);
					if (!((Object)(object)orCreateController == (Object)null))
					{
						orCreateController.ManualUpdate(Time.deltaTime);
					}
				}
			}
		}

		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		[HarmonyPatch(typeof(Humanoid), "StartAttack")]
		private static class Inspiration_Humanoid_StartAttack_Patch
		{
			private struct AttackSpendState
			{
				public bool ShouldSpend;

				public int Cost;

				public bool SecondaryAttack;

				[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(1)]
				public string WeaponPrefabName;
			}

			[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
			private static bool Prefix(Humanoid __instance, Character target, bool secondaryAttack, ref bool __result, ref AttackSpendState __state)
			{
				__state = default(AttackSpendState);
				if (!_initialized || !IsSystemEnabled())
				{
					return true;
				}
				Player val = (Player)(object)((__instance is Player) ? __instance : null);
				if (val == null)
				{
					return true;
				}
				ItemData currentWeapon = __instance.GetCurrentWeapon();
				if (currentWeapon == null)
				{
					return true;
				}
				InspirationUsageDef usageDef = GetUsageDef(currentWeapon);
				if (usageDef == null)
				{
					return true;
				}
				bool num = (secondaryAttack ? usageDef.SecondaryUsesInspiration : usageDef.PrimaryUsesInspiration);
				int num2 = (secondaryAttack ? usageDef.SecondaryInspirationCost : usageDef.PrimaryInspirationCost);
				if (!num || num2 <= 0)
				{
					return true;
				}
				InspirationController orCreateController = GetOrCreateController(val);
				if ((Object)(object)orCreateController == (Object)null)
				{
					return true;
				}
				string itemPrefabName = GetItemPrefabName(currentWeapon);
				if (!orCreateController.CanSpend(num2))
				{
					if (!orCreateController.ShouldSuppressNotEnoughMessage(num2, secondaryAttack, itemPrefabName))
					{
						((Character)__instance).Message((MessageType)2, "$msg_not_enough_inspiration_DO", 0, (Sprite)null);
					}
					Log(string.Format("Blocked {0} attack for {1}. Need={2}, Current={3}/{4}.", secondaryAttack ? "secondary" : "primary", itemPrefabName, num2, orCreateController.GetCurrentPoints(), orCreateController.GetCurrentMaxPoints()));
					__result = false;
					return false;
				}
				__state.ShouldSpend = true;
				__state.Cost = num2;
				__state.SecondaryAttack = secondaryAttack;
				__state.WeaponPrefabName = itemPrefabName;
				Log(string.Format("Allowed {0} attack for {1}. Cost={2}, Current={3}/{4}.", secondaryAttack ? "secondary" : "primary", itemPrefabName, num2, orCreateController.GetCurrentPoints(), orCreateController.GetCurrentMaxPoints()));
				return true;
			}

			[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
			private static void Postfix(Humanoid __instance, bool __result, AttackSpendState __state)
			{
				if (!_initialized || !IsSystemEnabled() || !__result || !__state.ShouldSpend)
				{
					return;
				}
				Player val = (Player)(object)((__instance is Player) ? __instance : null);
				if (val != null && TryGetController(val, out var controller) && !((Object)(object)controller == (Object)null))
				{
					if (controller.TrySpend(__state.Cost, __state.SecondaryAttack, __state.WeaponPrefabName))
					{
						Log(string.Format("Spent {0} inspiration on {1} attack. Weapon={2}, Remaining={3}/{4}.", __state.Cost, __state.SecondaryAttack ? "secondary" : "primary", __state.WeaponPrefabName, controller.GetCurrentPoints(), controller.GetCurrentMaxPoints()));
					}
					else
					{
						Log($"Failed to spend inspiration in Postfix for {__state.WeaponPrefabName}. Cost={__state.Cost}, Current={controller.GetCurrentPoints()}/{controller.GetCurrentMaxPoints()}.");
					}
				}
			}
		}

		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		[HarmonyPatch(typeof(StatusEffect), "GetTooltipString")]
		private static class Inspiration_StatusEffect_GetTooltipString_SourcePatch
		{
			[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
			private static void Postfix(StatusEffect __instance, ref string __result)
			{
				AppendStatusEffectSourceTooltip(__instance, ref __result);
			}
		}

		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		[HarmonyPatch(typeof(SE_Stats), "GetTooltipString")]
		private static class Inspiration_SEStats_GetTooltipString_SourcePatch
		{
			[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
			private static void Postfix(SE_Stats __instance, ref string __result)
			{
				AppendStatusEffectSourceTooltip((StatusEffect)(object)__instance, ref __result);
			}
		}

		[HarmonyPatch(typeof(SE_Shield), "GetTooltipString")]
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		private static class Inspiration_SEShield_GetTooltipString_SourcePatch
		{
			[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
			private static void Postfix(SE_Shield __instance, ref string __result)
			{
				AppendStatusEffectSourceTooltip((StatusEffect)(object)__instance, ref __result);
			}
		}

		[HarmonyPatch(typeof(ItemData), "GetTooltip", new Type[]
		{
			typeof(ItemData),
			typeof(int),
			typeof(bool),
			typeof(float),
			typeof(int)
		})]
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		private static class Inspiration_ItemTooltip_Patch
		{
			[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
			private static void Postfix(ItemData item, int qualityLevel, bool crafting, float worldLevel, int stackOverride, ref string __result)
			{
				if (_initialized && item != null)
				{
					string text = BuildItemSourceTooltipBlock(item);
					if (!string.IsNullOrEmpty(text))
					{
						__result = InsertItemSourceBlockBeforeSpecialSections(item, qualityLevel, __result, text);
					}
					string text2 = BuildUsageTooltipBlock(item);
					if (!string.IsNullOrEmpty(text2))
					{
						__result += text2;
					}
				}
			}
		}

		private const bool EnableInspirationDebugLogs = false;

		private const int AbsoluteMaxInspirationPoints = 8;

		private const string MsgNotEnoughInspiration = "$msg_not_enough_inspiration_DO";

		private const string LocItemInspirationActivates = "$item_inspiration_activates_DO";

		private const string LocItemInspirationGainSpeed = "$item_inspiration_gain_speed_DO";

		private const string LocItemInspirationMaxBonus = "$item_inspiration_max_bonus_DO";

		private const string LocItemInspirationCostsHeader = "$item_inspiration_costs_DO";

		private const string LocItemInspirationPrimaryCost = "$main_attack_DO";

		private const string LocItemInspirationSecondaryCost = "$secondary_attack_DO";

		private const string VisualStatusEffectAssetName = "SE_Inspiration_DO";

		private static StatusEffect _visualStatusEffect;

		private static int _visualStatusEffectNameHash;

		private const string InspirationPointGainFxPrefabName = "sfx_inspiration_gain_DO";

		private static bool _initialized;

		private const float NotEnoughMessageSuppressAfterSpendSeconds = 0.35f;

		private const string TooltipColor_Activates_Label = "#00E0C6";

		private const string TooltipColor_GainSpeed_Label = "#FFFFFF";

		private const string TooltipColor_GainSpeed_Value = "#00E0C6";

		private const string TooltipColor_MaxBonus_Label = "#FFFFFF";

		private const string TooltipColor_MaxBonus_Value = "#00E0C6";

		private const string TooltipColor_CostsHeader = "#00E0C6";

		private const string TooltipColor_PrimaryCost_Label = "#FFFFFF";

		private const string TooltipColor_PrimaryCost_Value = "#00E0C6";

		private const string TooltipColor_SecondaryCost_Label = "#FFFFFF";

		private const string TooltipColor_SecondaryCost_Value = "#00E0C6";

		private static readonly List<InspirationUsageDef> InspirationUsageDefs = new List<InspirationUsageDef>();

		private static readonly List<InspirationSourceDef> InspirationSourceDefs = new List<InspirationSourceDef>();

		private static void Log(string msg)
		{
		}

		public static void Initialize(ConfigFile config, AssetBundle assetBundle, ConfigSync configSync)
		{
			if (_initialized)
			{
				Log("Initialize called more than once. Ignored.");
				return;
			}
			InspirationSystemConfigs.Initialize(config, configSync);
			if ((Object)(object)assetBundle == (Object)null)
			{
				Log("AssetBundle is null. SE_Inspiration_DO could not be loaded.");
			}
			else
			{
				try
				{
					_visualStatusEffect = assetBundle.LoadAsset<StatusEffect>("SE_Inspiration_DO");
					if ((Object)(object)_visualStatusEffect == (Object)null)
					{
						Log("Could not load visual status effect asset 'SE_Inspiration_DO'.");
					}
					else
					{
						_visualStatusEffectNameHash = _visualStatusEffect.NameHash();
						Log("Loaded visual status effect asset 'SE_Inspiration_DO'.");
					}
				}
				catch (Exception arg)
				{
					Log(string.Format("Exception while loading '{0}': {1}", "SE_Inspiration_DO", arg));
				}
			}
			_initialized = true;
			Log("InspirationSystem initialized.");
		}

		internal static void SetDefinitions(List<InspirationSourceDef> sources, List<InspirationUsageDef> consumers)
		{
			InspirationSourceDefs.Clear();
			InspirationUsageDefs.Clear();
			if (sources != null)
			{
				InspirationSourceDefs.AddRange(sources);
			}
			if (consumers != null)
			{
				InspirationUsageDefs.AddRange(consumers);
			}
			Log($"Definitions set. Sources={InspirationSourceDefs.Count}, Consumers={InspirationUsageDefs.Count}.");
		}

		public static bool IsSystemEnabled()
		{
			if (_initialized)
			{
				return InspirationSystemConfigs.IsSystemEnabled();
			}
			return false;
		}

		public static float GetProgressPerPoint()
		{
			return InspirationSystemConfigs.GetProgressPerPoint();
		}

		public static float GetBaseGainPerSecond()
		{
			return InspirationSystemConfigs.GetBaseGainPerSecond();
		}

		public static int GetBaseMaxPoints()
		{
			return InspirationSystemConfigs.GetBaseMaxPoints();
		}

		public static bool IsPointGainFxEnabled()
		{
			return InspirationSystemConfigs.IsPointGainFxEnabled();
		}

		public static StatusEffect GetVisualStatusEffect()
		{
			return _visualStatusEffect;
		}

		public static int GetVisualStatusEffectNameHash()
		{
			return _visualStatusEffectNameHash;
		}

		public static InspirationController GetOrCreateController(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return null;
			}
			InspirationController inspirationController = ((Component)player).GetComponent<InspirationController>();
			if ((Object)(object)inspirationController == (Object)null)
			{
				inspirationController = ((Component)player).gameObject.AddComponent<InspirationController>();
				inspirationController.Setup(player);
				Log("Created InspirationController on local player.");
			}
			return inspirationController;
		}

		public static bool TryGetController(Player player, out InspirationController controller)
		{
			controller = null;
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			controller = ((Component)player).GetComponent<InspirationController>();
			return (Object)(object)controller != (Object)null;
		}

		public static InspirationUsageDef GetUsageDef(ItemData item)
		{
			string itemPrefabName = GetItemPrefabName(item);
			if (string.IsNullOrEmpty(itemPrefabName))
			{
				return null;
			}
			for (int i = 0; i < InspirationUsageDefs.Count; i++)
			{
				if (string.Equals(InspirationUsageDefs[i].PrefabName, itemPrefabName, StringComparison.Ordinal))
				{
					return InspirationUsageDefs[i];
				}
			}
			return null;
		}

		public static string GetItemPrefabName(ItemData item)
		{
			if (item == null)
			{
				return string.Empty;
			}
			if ((Object)(object)item.m_dropPrefab != (Object)null)
			{
				return ((Object)item.m_dropPrefab).name;
			}
			return string.Empty;
		}

		private static string GetSourceDisplayName(InspirationSourceDef def)
		{
			return $"{def.SourceType}:{def.SourceName}";
		}

		private static string FormatPercent(float value)
		{
			if (Mathf.Approximately(value, Mathf.Round(value)))
			{
				return Mathf.RoundToInt(value).ToString();
			}
			return value.ToString("0.#");
		}

		private static string FormatPercentSigned(float value)
		{
			string text = FormatPercent(value);
			if (!(value > 0f))
			{
				return text;
			}
			return "+" + text;
		}

		private static string FormatIntSigned(int value)
		{
			if (value < 0)
			{
				return value.ToString();
			}
			return "+" + value;
		}

		private static string ApplyColor(string raw, string hexColor)
		{
			if (string.IsNullOrEmpty(raw))
			{
				return string.Empty;
			}
			if (string.IsNullOrEmpty(hexColor))
			{
				return raw;
			}
			return "<color=" + hexColor + ">" + raw + "</color>";
		}

		private static string BuildTextLine(string labelKey, string labelColor)
		{
			return ApplyColor(Localize(labelKey), labelColor);
		}

		private static string BuildStatLine(string labelKey, string value, string labelColor, string valueColor)
		{
			string text = ApplyColor(Localize(labelKey), labelColor);
			string text2 = ApplyColor(value, valueColor);
			return text + ": " + text2;
		}

		private static void AddSourceDefTooltipLines(InspirationSourceDef def, List<string> lines)
		{
			if (def != null && lines != null)
			{
				if (def.ActivatesInspiration)
				{
					lines.Add(BuildTextLine("$item_inspiration_activates_DO", "#00E0C6"));
				}
				if (!Mathf.Approximately(def.InspirationGainPercentBonus, 0f))
				{
					lines.Add(BuildStatLine("$item_inspiration_gain_speed_DO", FormatPercentSigned(def.InspirationGainPercentBonus) + "%", "#FFFFFF", "#00E0C6"));
				}
				if (def.MaxInspirationBonus != 0)
				{
					lines.Add(BuildStatLine("$item_inspiration_max_bonus_DO", FormatIntSigned(def.MaxInspirationBonus), "#FFFFFF", "#00E0C6"));
				}
			}
		}

		private static string BuildItemSourceTooltipBlock(ItemData item)
		{
			if (item == null)
			{
				return string.Empty;
			}
			string itemPrefabName = GetItemPrefabName(item);
			if (string.IsNullOrEmpty(itemPrefabName))
			{
				return string.Empty;
			}
			List<string> list = new List<string>();
			for (int i = 0; i < InspirationSourceDefs.Count; i++)
			{
				InspirationSourceDef inspirationSourceDef = InspirationSourceDefs[i];
				if (inspirationSourceDef != null && inspirationSourceDef.SourceType == InspirationSourceType.Item && string.Equals(itemPrefabName, inspirationSourceDef.SourceName, StringComparison.Ordinal))
				{
					AddSourceDefTooltipLines(inspirationSourceDef, list);
				}
			}
			if (list.Count == 0)
			{
				return string.Empty;
			}
			return "\n" + string.Join("\n", list);
		}

		private static string BuildStatusEffectSourceTooltipBlock(StatusEffect se)
		{
			if ((Object)(object)se == (Object)null)
			{
				return string.Empty;
			}
			string name = ((Object)se).name;
			string prefabName = Utils.GetPrefabName(name);
			List<string> list = new List<string>();
			for (int i = 0; i < InspirationSourceDefs.Count; i++)
			{
				InspirationSourceDef inspirationSourceDef = InspirationSourceDefs[i];
				if (inspirationSourceDef != null && inspirationSourceDef.SourceType == InspirationSourceType.StatusEffect && StatusEffectNameMatchesSource(name, prefabName, inspirationSourceDef.SourceName))
				{
					AddSourceDefTooltipLines(inspirationSourceDef, list);
				}
			}
			if (list.Count == 0)
			{
				return string.Empty;
			}
			return string.Join("\n", list);
		}

		private static void AppendStatusEffectSourceTooltip(StatusEffect se, ref string result)
		{
			if (!_initialized || !IsSystemEnabled() || (Object)(object)se == (Object)null || se.NameHash() == _visualStatusEffectNameHash)
			{
				return;
			}
			string text = BuildStatusEffectSourceTooltipBlock(se);
			if (!string.IsNullOrEmpty(text))
			{
				if (!string.IsNullOrEmpty(result))
				{
					result += "\n";
				}
				result += text;
			}
		}

		private static string BuildUsageTooltipBlock(ItemData item)
		{
			if (item == null)
			{
				return string.Empty;
			}
			InspirationUsageDef usageDef = GetUsageDef(item);
			if (usageDef == null)
			{
				return string.Empty;
			}
			List<string> list = new List<string>();
			if (usageDef.PrimaryUsesInspiration && usageDef.PrimaryInspirationCost > 0)
			{
				list.Add(BuildStatLine("$main_attack_DO", usageDef.PrimaryInspirationCost.ToString(), "#FFFFFF", "#00E0C6"));
			}
			if (usageDef.SecondaryUsesInspiration && usageDef.SecondaryInspirationCost > 0)
			{
				list.Add(BuildStatLine("$secondary_attack_DO", usageDef.SecondaryInspirationCost.ToString(), "#FFFFFF", "#00E0C6"));
			}
			if (list.Count == 0)
			{
				return string.Empty;
			}
			string text = ApplyColor(Localize("$item_inspiration_costs_DO"), "#00E0C6");
			return "\n\n" + text + "\n" + string.Join("\n", list);
		}

		private static bool StatusEffectNameMatchesSource(string seRawName, string seCleanName, string sourceSeName)
		{
			if (string.IsNullOrEmpty(sourceSeName))
			{
				return false;
			}
			if (!string.IsNullOrEmpty(seRawName) && string.Equals(seRawName, sourceSeName, StringComparison.Ordinal))
			{
				return true;
			}
			if (!string.IsNullOrEmpty(seCleanName) && string.Equals(seCleanName, sourceSeName, StringComparison.Ordinal))
			{
				return true;
			}
			if (!string.IsNullOrEmpty(seCleanName) && StringExtensionMethods.GetStableHashCode(seCleanName) == StringExtensionMethods.GetStableHashCode(sourceSeName))
			{
				return true;
			}
			return false;
		}

		private static string InsertItemSourceBlockBeforeSpecialSections(ItemData item, int qualityLevel, string result, string block)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			if (item == null || string.IsNullOrEmpty(result) || string.IsNullOrEmpty(block))
			{
				return result;
			}
			float num = 0f;
			if ((Object)(object)Player.m_localPlayer != (Object)null && item.m_shared != null)
			{
				num = ((Character)Player.m_localPlayer).GetSkillLevel(item.m_shared.m_skillType);
			}
			string statusEffectTooltip = item.GetStatusEffectTooltip(qualityLevel, num);
			string chainTooltip = item.GetChainTooltip(qualityLevel, num);
			string setStatusEffectTooltip = item.GetSetStatusEffectTooltip(qualityLevel, num);
			int num2 = -1;
			if (!string.IsNullOrEmpty(statusEffectTooltip))
			{
				int num3 = result.IndexOf(statusEffectTooltip, StringComparison.Ordinal);
				if (num3 >= 0)
				{
					num2 = ((num3 - 2 >= 0 && result.Substring(num3 - 2, 2) == "\n\n") ? (num3 - 2) : num3);
				}
			}
			if (num2 < 0 && !string.IsNullOrEmpty(chainTooltip))
			{
				int num4 = result.IndexOf(chainTooltip, StringComparison.Ordinal);
				if (num4 >= 0)
				{
					num2 = ((num4 - 2 >= 0 && result.Substring(num4 - 2, 2) == "\n\n") ? (num4 - 2) : num4);
				}
			}
			if (num2 < 0)
			{
				int num5 = result.IndexOf("\n$item_eitrregen_modifier:", StringComparison.Ordinal);
				if (num5 >= 0)
				{
					num2 = num5;
				}
			}
			if (num2 < 0 && !string.IsNullOrEmpty(setStatusEffectTooltip))
			{
				int num6 = result.IndexOf("\n\n$item_seteffect", StringComparison.Ordinal);
				if (num6 >= 0)
				{
					num2 = num6;
				}
			}
			if (num2 < 0)
			{
				int num7 = result.IndexOf("\n$item_fulladrenaline:", StringComparison.Ordinal);
				if (num7 >= 0)
				{
					num2 = num7;
				}
			}
			if (num2 >= 0)
			{
				return result.Insert(num2, block);
			}
			return result + block;
		}

		private static string Localize(string key)
		{
			if (Localization.instance == null)
			{
				return key;
			}
			return Localization.instance.Localize(key);
		}

		public static bool TryGetUIData(Player player, out InspirationUIData data)
		{
			data = default(InspirationUIData);
			if (!_initialized || !IsSystemEnabled() || (Object)(object)player == (Object)null)
			{
				return false;
			}
			if (!TryGetController(player, out var controller))
			{
				return false;
			}
			if (!controller.IsActive())
			{
				return false;
			}
			float progressPerPoint = GetProgressPerPoint();
			float currentProgress = controller.GetCurrentProgress();
			int currentPoints = Mathf.Clamp(controller.GetCurrentPoints(), 0, 8);
			int maxPoints = Mathf.Clamp(controller.GetCurrentMaxPoints(), 0, 8);
			data = new InspirationUIData
			{
				IsActive = true,
				CurrentPoints = currentPoints,
				MaxPoints = maxPoints,
				Progress = currentProgress,
				ProgressMax = progressPerPoint,
				ProgressNormalized = ((progressPerPoint > 0f) ? Mathf.Clamp01(currentProgress / progressPerPoint) : 0f)
			};
			return true;
		}

		public static int GetCurrentPointIndex(Player player)
		{
			if (!TryGetController(player, out var controller))
			{
				return 0;
			}
			return Mathf.Clamp(controller.GetCurrentPoints(), 0, 8);
		}

		public static bool HasActiveInspiration(Player player)
		{
			if (TryGetController(player, out var controller))
			{
				return controller.IsActive();
			}
			return false;
		}
	}
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[HarmonyPatch]
	public static class ContainerInitialLoot
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(Container), "AddDefaultItems")]
		private static void AddDefaultItems_Prefix(Container __instance)
		{
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance == (Object)null)
			{
				return;
			}
			ZNetView component = ((Component)__instance).GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || !component.IsValid() || !component.IsOwner() || (Object)(object)ObjectDB.instance == (Object)null)
			{
				return;
			}
			string rikoIdFromContainerPrefab = GetRikoIdFromContainerPrefab(Utils.GetPrefabName(((Object)((Component)__instance).gameObject).name));
			if (string.IsNullOrEmpty(rikoIdFromContainerPrefab) || !LivingContainerConfig.RikoConfigs.TryGetValue(rikoIdFromContainerPrefab, out var value))
			{
				return;
			}
			DropTable defaultItems = __instance.m_defaultItems;
			if (defaultItems == null)
			{
				return;
			}
			string text = value.LootTable?.Value ?? string.Empty;
			if (string.IsNullOrWhiteSpace(text))
			{
				return;
			}
			string[] array = text.Split(new char[2] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
			defaultItems.m_drops.Clear();
			string[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				string text2 = array2[i].Trim();
				if (string.IsNullOrWhiteSpace(text2) || text2.StartsWith("#") || text2.StartsWith("//"))
				{
					continue;
				}
				string[] array3 = text2.Split(new char[1] { ',' });
				if (array3.Length < 4)
				{
					continue;
				}
				string text3 = array3[0].Trim();
				if (int.TryParse(array3[1].Trim(), out var result) && int.TryParse(array3[2].Trim(), out var result2) && float.TryParse(array3[3].Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out var result3))
				{
					GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(text3);
					if (!((Object)(object)itemPrefab == (Object)null))
					{
						DropData val = default(DropData);
						val.m_item = itemPrefab;
						val.m_stackMin = Mathf.Max(1, result);
						val.m_stackMax = Mathf.Max(result, result2);
						val.m_weight = Mathf.Max(0f, result3);
						val.m_dontScale = false;
						DropData item = val;
						defaultItems.m_drops.Add(item);
					}
				}
			}
		}

		private static string GetRikoIdFromContainerPrefab(string containerPrefabName)
		{
			if (string.IsNullOrEmpty(containerPrefabName))
			{
				return string.Empty;
			}
			if (!containerPrefabName.StartsWith("EncounterCreatureRiko") || !containerPrefabName.EndsWith("DO"))
			{
				return string.Empty;
			}
			return containerPrefabName.Substring("EncounterCreatureRiko".Length, containerPrefabName.Length - "EncounterCreatureRiko".Length - "DO".Length);
		}
	}
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	internal static class LivingContainerConfig
	{
		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
		internal class RikoSpawnConfig
		{
			public ConfigEntry<float> CheckInterval;

			public ConfigEntry<float> SpawnChance;

			public ConfigEntry<int> MaxInWorld;

			public ConfigEntry<float> MinDistance;

			public ConfigEntry<float> MaxDistance;

			public ConfigEntry<float> MinAltitude;

			public ConfigEntry<float> MaxAltitude;

			public ConfigEntry<int> ContainerWidth;

			public ConfigEntry<int> ContainerHeight;

			public ConfigEntry<int> ContainerLootMin;

			public ConfigEntry<int> ContainerLootMax;

			public ConfigEntry<string> LootTable;
		}

		private static ConfigEntry<Magic_SupremacyPlugin.Toggle> _rikoEnabled;

		private static ConfigFile _config;

		private static ConfigSync _configSync;

		internal static readonly Dictionary<string, RikoSpawnConfig> RikoConfigs = new Dictionary<string, RikoSpawnConfig>();

		private const string DefaultLoot_Blackforest = "FoodEitrBlackforestCookieRikoDO,2,4,12\r\nDimEitrRemnantDO,1,3,10\r\nPageArcaneDO,1,2,3\r\nSpiritTotemDO,1,3,10\r\nSpiritMushroomDO,1,3,10\r\nSurtlingCore,1,2,8\r\nCoins,1,50,7";

		private const string DefaultLoot_Swamp = "FoodEitrSwampCookieRikoDO,2,4,10\r\nDimEitrRemnantDO,1,3,10\r\nPageArcaneDO,1,2,3\r\nSpiritDeathDO,1,3,10\r\nChain,1,4,8\r\nCoins,1,50,7";

		private const string DefaultLoot_Mountain = "FoodEitrMountainCookieRikoDO,2,4,10\r\nDimEitrRemnantDO,1,3,10\r\nPageArcaneDO,1,2,3\r\nSpiritFrostDO,1,3,10\r\nJuteRed,2,5,7\r\nCoins,1,75,7";

		private const string DefaultLoot_Plains = "FoodEitrPlainsCookieRikoDO,2,4,10\r\nDimEitrRemnantDO,1,3,10\r\nPageArcaneDO,1,2,3\r\nSpiritFireDO,1,3,10\r\nSpiritStoneDO,1,3,10\r\nTar,6,10,8\r\nCoins,1,75,7";

		private const string DefaultLoot_Mistlands = "FoodEitrMistlandsCookieRikoDO,1,4,12\r\nPageArcaneDO,1,2,3\r\nSpiritWindDO,1,3,10\r\nSpiritLightDO,1,3,10\r\nSofttissue,1,3,6\r\nRoyalJelly,2,6,8\r\nDvergrNeedle,1,1,1\r\nJuteBlue,2,5,7\r\nCoins,1,100,7";

		private const string DefaultLoot_Ashlands = "FoodEitrAshlandsCookieRikoDO,1,4,10\r\nPageArcaneDO,1,2,3\r\nSpiritStormDO,1,3,10\r\nSpiritBloodDO,1,3,10\r\nGemstoneRed,1,1,1\r\nGemstoneBlue,1,1,1\r\nGemstoneGreen,1,1,1\r\nSofttissue,2,5,8\r\nCharcoalResin,2,6,10\r\nMoltenCore,1,2,3\r\nCelestialFeather,1,1,2\r\nGemstoneCelestineDO,1,1,2\r\nGemstoneCryoliteDO,1,1,2\r\nCoins,1,150,7";

		internal static bool IsRikoEnabled()
		{
			if (_rikoEnabled != null)
			{
				return _rikoEnabled.Value == Magic_SupremacyPlugin.Toggle.On;
			}
			return false;
		}

		internal static void Init(ConfigFile config, ConfigSync configSync)
		{
			_config = config;
			_configSync = configSync;
			CreateGlobalConfig();
			CreateRikoConfigs();
		}

		private static void CreateGlobalConfig()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			_rikoEnabled = _config.Bind<Magic_SupremacyPlugin.Toggle>("Riko - General", "Enabled", Magic_SupremacyPlugin.Toggle.On, new ConfigDescription("Enable or disable Riko encounters entirely.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 100
				}
			}));
			_configSync.AddConfigEntry<Magic_SupremacyPlugin.Toggle>(_rikoEnabled);
		}

		private static void CreateRikoConfigs()
		{
			CreateRiko("Blackforest", "Black Forest", 480f, 0.2f, 3, 18f, 36f, 0f, 2000f, 4, 1, 3, 4, "FoodEitrBlackforestCookieRikoDO,2,4,12\r\nDimEitrRemnantDO,1,3,10\r\nPageArcaneDO,1,2,3\r\nSpiritTotemDO,1,3,10\r\nSpiritMushroomDO,1,3,10\r\nSurtlingCore,1,2,8\r\nCoins,1,50,7");
			CreateRiko("Swamp", "Swamp", 480f, 0.2f, 3, 18f, 36f, -1f, 2000f, 4, 1, 3, 4, "FoodEitrSwampCookieRikoDO,2,4,10\r\nDimEitrRemnantDO,1,3,10\r\nPageArcaneDO,1,2,3\r\nSpiritDeathDO,1,3,10\r\nChain,1,4,8\r\nCoins,1,50,7");
			CreateRiko("Mountain", "Mountain", 480f, 0.2f, 3, 18f, 36f, 10f, 2000f, 4, 1, 3, 4, "FoodEitrMountainCookieRikoDO,2,4,10\r\nDimEitrRemnantDO,1,3,10\r\nPageArcaneDO,1,2,3\r\nSpiritFrostDO,1,3,10\r\nJuteRed,2,5,7\r\nCoins,1,75,7");
			CreateRiko("Plains", "Plains", 480f, 0.2f, 3, 18f, 36f, 0f, 2000f, 4, 1, 3, 4, "FoodEitrPlainsCookieRikoDO,2,4,10\r\nDimEitrRemnantDO,1,3,10\r\nPageArcaneDO,1,2,3\r\nSpiritFireDO,1,3,10\r\nSpiritStoneDO,1,3,10\r\nTar,6,10,8\r\nCoins,1,75,7");
			CreateRiko("Mistlands", "Mistlands", 420f, 0.2f, 3, 15f, 40f, 12f, 2000f, 4, 1, 2, 4, "FoodEitrMistlandsCookieRikoDO,1,4,12\r\nPageArcaneDO,1,2,3\r\nSpiritWindDO,1,3,10\r\nSpiritLightDO,1,3,10\r\nSofttissue,1,3,6\r\nRoyalJelly,2,6,8\r\nDvergrNeedle,1,1,1\r\nJuteBlue,2,5,7\r\nCoins,1,100,7");
			CreateRiko("Ashlands", "Ashlands", 540f, 0.2f, 3, 18f, 36f, 0f, 2000f, 4, 1, 2, 3, "FoodEitrAshlandsCookieRikoDO,1,4,10\r\nPageArcaneDO,1,2,3\r\nSpiritStormDO,1,3,10\r\nSpiritBloodDO,1,3,10\r\nGemstoneRed,1,1,1\r\nGemstoneBlue,1,1,1\r\nGemstoneGreen,1,1,1\r\nSofttissue,2,5,8\r\nCharcoalResin,2,6,10\r\nMoltenCore,1,2,3\r\nCelestialFeather,1,1,2\r\nGemstoneCelestineDO,1,1,2\r\nGemstoneCryoliteDO,1,1,2\r\nCoins,1,150,7");
		}

		private static void CreateRiko(string id, string displayName, float checkInterval, float spawnChance, int maxInWorld, float minDistance, float maxDistance, float minAltitude, float maxAltitude, int containerWidth, int containerHeight, int lootMin, int lootMax, string defaultLoot)
		{
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Expected O, but got Unknown
			string text = "Riko - " + displayName;
			RikoSpawnConfig rikoSpawnConfig = new RikoSpawnConfig();
			rikoSpawnConfig.CheckInterval = Bind(text, "Spawn Check Interval", checkInterval, "Seconds between spawn checks.\nApplied after the next Riko spawn check or after game restart.", 80);
			rikoSpawnConfig.SpawnChance = Bind(text, "Spawn Chance", spawnChance, "Chance for Riko to appear on each spawn check.", 70);
			rikoSpawnConfig.MaxInWorld = Bind(text, "Spawn Max In World", maxInWorld, "Maximum number of Riko encounters that can exist in the world at the same time.", 60);
			rikoSpawnConfig.MinDistance = Bind(text, "Spawn Min Distance", minDistance, "Minimum distance from the player where Riko can spawn.", 50);
			rikoSpawnConfig.MaxDistance = Bind(text, "Spawn Max Distance", maxDistance, "Maximum distance from the player where Riko can spawn.", 40);
			rikoSpawnConfig.MinAltitude = Bind(text, "Spawn Min Altitude", minAltitude, "Minimum ground altitude required for Riko to spawn.", 30);
			rikoSpawnConfig.MaxAltitude = Bind(text, "Spawn Max Altitude", maxAltitude, "Maximum ground altitude allowed for Riko to spawn.", 20);
			rikoSpawnConfig.ContainerWidth = Bind(text, "Container Width", containerWidth, "Number of item slots horizontally.\nApplied only to newly spawned Riko.", 19);
			rikoSpawnConfig.ContainerHeight = Bind(text, "Container Height", containerHeight, "Number of item slots vertically.\nApplied only to newly spawned Riko.", 18);
			rikoSpawnConfig.ContainerLootMin = Bind(text, "Container Loot Min", lootMin, "Minimum number of loot items inside the container.\nApplied only to newly spawned Riko.", 17);
			rikoSpawnConfig.ContainerLootMax = Bind(text, "Container Loot Max", lootMax, "Maximum number of loot items inside the container.\nApplied only to newly spawned Riko.", 16);
			rikoSpawnConfig.LootTable = _config.Bind<string>(text, "Loot Table", defaultLoot, new ConfigDescription("Ratio is compared between entries.\nAny values can be used. Only their ratio matters.\nHigher value = more common loot.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 10,
					CustomDrawer = DrawLootTable
				}
			}));
			RikoSpawnConfig rikoSpawnConfig2 = rikoSpawnConfig;
			_configSync.AddConfigEntry<float>(rikoSpawnConfig2.CheckInterval);
			_configSync.AddConfigEntry<float>(rikoSpawnConfig2.SpawnChance);
			_configSync.AddConfigEntry<int>(rikoSpawnConfig2.MaxInWorld);
			_configSync.AddConfigEntry<float>(rikoSpawnConfig2.MinDistance);
			_configSync.AddConfigEntry<float>(rikoSpawnConfig2.MaxDistance);
			_configSync.AddConfigEntry<float>(rikoSpawnConfig2.MinAltitude);
			_configSync.AddConfigEntry<float>(rikoSpawnConfig2.MaxAltitude);
			_configSync.AddConfigEntry<int>(rikoSpawnConfig2.ContainerWidth);
			_configSync.AddConfigEntry<int>(rikoSpawnConfig2.ContainerHeight);
			_configSync.AddConfigEntry<int>(rikoSpawnConfig2.ContainerLootMin);
			_configSync.AddConfigEntry<int>(rikoSpawnConfig2.ContainerLootMax);
			_configSync.AddConfigEntry<string>(rikoSpawnConfig2.LootTable);
			RikoConfigs[id] = rikoSpawnConfig2;
		}

		private static ConfigEntry<T> Bind<[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)] T>(string section, string key, T value, string description, int order)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			ConfigEntry<T> val = _config.Bind<T>(section, key, value, new ConfigDescription(description, (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = order
				}
			}));
			_configSync.AddConfigEntry<T>(val);
			return val;
		}

		private static void DrawLootTable(ConfigEntryBase entry)
		{
			List<string> list = (from l in ((entry.BoxedValue as string) ?? "").Split(new char[1] { '\n' }, StringSplitOptions.RemoveEmptyEntries)
				select l.Trim() into l
				where !l.StartsWith("#")
				select l).ToList();
			GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label("Prefab", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(200f) });
			GUILayout.Label("Min", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(36f) });
			GUILayout.Label("Max", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(36f) });
			GUILayout.Label("Ratio", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(44f) });
			GUILayout.Space(22f);
			GUILayout.EndHorizontal();
			for (int i = 0; i < list.Count; i++)
			{
				string[] array = list[i].Split(new char[1] { ',' });
				if (array.Length >= 4)
				{
					GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
					array[0] = GUILayout.TextField(array[0], (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(200f) });
					array[1] = GUILayout.TextField(array[1], (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(36f) });
					array[2] = GUILayout.TextField(array[2], (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(36f) });
					array[3] = GUILayout.TextField(array[3], (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(44f) });
					if (GUILayout.Button("X", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(22f) }))
					{
						list.RemoveAt(i);
						i--;
					}
					else
					{
						list[i] = string.Join(",", array);
					}
					GUILayout.EndHorizontal();
				}
			}
			if (GUILayout.Button("+ Add Entry", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(120f) }))
			{
				list.Add("ItemPrefab,1,1,1");
			}
			entry.BoxedValue = string.Join("\n", list);
			GUILayout.EndVertical();
		}
	}
	[HarmonyPatch(typeof(Projectile), "OnHit")]
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	public static class ProjectileLifeSteal
	{
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		private enum LifeStealType
		{
			Percent,
			Flat
		}

		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		private class LifeStealEntry
		{
			public LifeStealType Type;

			public float Value;

			public LifeStealEntry(LifeStealType type, float value)
			{
				Type = type;
				Value = value;
			}
		}

		private static readonly ManualLogSource Log = Logger.CreateLogSource("ProjectileLifeSteal");

		private const bool DEBUG = false;

		private static readonly Dictionary<string, LifeStealEntry> LifeStealMap = new Dictionary<string, LifeStealEntry>(StringComparer.OrdinalIgnoreCase) { 
		{
			"projectile_bloodcaller_staff_shotgun_DO",
			new LifeStealEntry(LifeStealType.Flat, 1.5f)
		} };

		[HarmonyPrefix]
		private static void Prefix(Projectile __instance, Collider collider, Vector3 hitPoint, bool water, Vector3 normal)
		{
			try
			{
				if ((Object)(object)collider == (Object)null || water)
				{
					return;
				}
				string key = SafePrefabName((__instance != null) ? ((Component)__instance).gameObject : null);
				if (!LifeStealMap.TryGetValue(key, out var value))
				{
					return;
				}
				Character val = (Character)(((object)__instance.m_owner) ?? ((object)Player.m_localPlayer));
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				Character componentInParent = ((Component)collider).GetComponentInParent<Character>();
				if (!((Object)(object)componentInParent == (Object)null) && !((Object)(object)componentInParent == (Object)(object)val) && BaseAI.IsEnemy(val, componentInParent))
				{
					float num = GetProjectileDamage(__instance);
					if (num <= 0f)
					{
						num = 10f;
					}
					float num2 = 0f;
					if (value.Type == LifeStealType.Percent)
					{
						num2 = num * value.Value;
					}
					else if (value.Type == LifeStealType.Flat)
					{
						num2 = value.Value;
					}
					if (num2 > 0f)
					{
						val.Heal(num2, true);
					}
				}
			}
			catch (Exception)
			{
			}
		}

		private static float GetProjectileDamage(Projectile proj)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				HitData value = Traverse.Create((object)proj).Field<HitData>("m_lastHit").Value;
				if (value != null)
				{
					return value.GetTotalDamage();
				}
			}
			catch
			{
			}
			try
			{
				DamageTypes value2 = Traverse.Create((object)proj).Field<DamageTypes>("m_damage").Value;
				return ((DamageTypes)(ref value2)).GetTotalDamage();
			}
			catch
			{
			}
			return 0f;
		}

		private static string SafePrefabName(GameObject go)
		{
			if (!Object.op_Implicit((Object)(object)go))
			{
				return string.Empty;
			}
			try
			{
				return Utils.GetPrefabName(go);
			}
			catch
			{
				string name = ((Object)go).name;
				int num = name.IndexOf('(');
				return (num > 0) ? name.Substring(0, num) : name;
			}
		}
	}
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	[HarmonyPatch]
	public static class ProjectileFriendlyHit
	{
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		private class PFH_Tracker : MonoBehaviour
		{
			public bool initialized;

			public Vector3 lastPos;

			public float bornTime;

			public float ttl;

			public bool forcedOnce;

			public bool seApplied;
		}

		private static readonly ManualLogSource Log = Logger.CreateLogSource("ProjectileFriendlyHit");

		private const bool DEBUG = false;

		private static readonly HashSet<string> AllowList = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "projectile_bloodcaller_staff_heal_DO" };

		private static readonly Dictionary<string, string> SeMap = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) { { "projectile_bloodcaller_staff_heal_DO", "SE_BloodcallerHeal_DO" } };

		[HarmonyPatch(typeof(Projectile), "Awake")]
		[HarmonyPostfix]
		private static void Awake_Postfix(Projectile __instance)
		{
			string item = SafePrefabName(((Component)__instance).gameObject);
			if (AllowList.Contains(item))
			{
				PFH_Tracker pFH_Tracker = ((Component)__instance).gameObject.GetComponent<PFH_Tracker>() ?? ((Component)__instance).gameObject.AddComponent<PFH_Tracker>();
				pFH_Tracker.initialized = false;
				pFH_Tracker.forcedOnce = false;
				pFH_Tracker.seApplied = false;
				pFH_Tracker.bornTime = Time.time;
				float value = Traverse.Create((object)__instance).Field<float>("m_ttl").Value;
				pFH_Tracker.ttl = ((value > 0f) ? value : 6f);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Projectile), "OnHit")]
		private static bool OnHit_Prefix(Projectile __instance, Collider collider, Vector3 hitPoint, bool water, Vector3 normal)
		{
			string text = SafePrefabName(Object.op_Implicit((Object)(object)__instance) ? ((Component)__instance).gameObject : null);
			if (!AllowList.Contains(text))
			{
				return true;
			}
			try
			{
				Character val = (Character)(((object)__instance.m_owner) ?? ((object)Player.m_localPlayer));
				if ((Object)(object)val == (Object)null)
				{
					return true;
				}
				if (water)
				{
					return true;
				}
				if ((Object)(object)collider == (Object)null)
				{
					return true;
				}
				Character componentInParent = ((Component)collider).GetComponentInParent<Character>();
				if ((Object)(object)componentInParent == (Object)null)
				{
					return true;
				}
				if (componentInParent == val)
				{
					return false;
				}
				PFH_Tracker component = ((Component)__instance).GetComponent<PFH_Tracker>();
				if (IsFriendlyTo(val, componentInParent))
				{
					if ((Object)(object)component != (Object)null && !component.seApplied)
					{
						TryApplyMappedSE(text, val, componentInParent);
						component.seApplied = true;
					}
					return true;
				}
				return false;
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[PFH] OnHit exception: " + ex.Message));
				return true;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Projectile), "FixedUpdate")]
		private static void FixedUpdate_Postfix(Projectile __instance)
		{
			string item = SafePrefabName(Object.op_Implicit((Object)(object)__instance) ? ((Component)__instance).gameObject : null);
			if (AllowList.Contains(item))
			{
				GameObject gameObject = ((Component)__instance).gameObject;
				PFH_Tracker component = gameObject.GetComponent<PFH_Tracker>();
				if (!((Object)(object)component == (Object)null) && Time.time - component.bornTime > component.ttl + 0.5f && Object.op_Implicit((Object)(object)ZNetScene.instance) && Object.op_Implicit((Object)(object)gameObject))
				{
					ZNetScene.instance.Destroy(gameObject);
				}
			}
		}

		private static void TryApplyMappedSE(string projName, Character owner, Character target)
		{
			if (!SeMap.TryGetValue(projName, out var value) || string.IsNullOrWhiteSpace(value))
			{
				return;
			}
			ObjectDB instance = ObjectDB.instance;
			if (!Object.op_Implicit((Object)(object)instance))
			{
				return;
			}
			int stableHashCode = StringExtensionMethods.GetStableHashCode(value);
			StatusEffect statusEffect = instance.GetStatusEffect(stableHashCode);
			if (!((Object)(object)statusEffect == (Object)null))
			{
				SEMan sEMan = target.GetSEMan();
				if (sEMan != null)
				{
					sEMan.AddStatusEffect(statusEffect, true, 0, 0f);
				}
			}
		}

		private static bool IsFriendlyTo(Character owner, Character target)
		{
			try
			{
				if (target.IsTamed())
				{
					return true;
				}
			}
			catch
			{
			}
			if (target.IsPlayer())
			{
				Player val = (Player)(object)((owner is Player) ? owner : null);
				Player val2 = (Player)(object)((target is Player) ? target : null);
				bool num = (Object)(object)val != (Object)null && ((Character)val).IsPVPEnabled();
				bool flag = (Object)(object)val2 != (Object)null && ((Character)val2).IsPVPEnabled();
				if (!num && !flag)
				{
					return true;
				}
			}
			if (!BaseAI.IsEnemy(owner, target) && !BaseAI.IsEnemy(target, owner))
			{
				return true;
			}
			return false;
		}

		private static string SafePrefabName(GameObject go)
		{
			if (!Object.op_Implicit((Object)(object)go))
			{
				return string.Empty;
			}
			try
			{
				return Utils.GetPrefabName(go);
			}
			catch
			{
				string name = ((Object)go).name;
				int num = name.IndexOf('(');
				return (num > 0) ? name.Substring(0, num) : name;
			}
		}
	}
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	internal static class PrefabOwnerBinderConfig
	{
		internal static readonly HashSet<string> AllowList = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
		{
			"aoe_totemcaller_shield_break_DO", "aoe_totemcaller_staff_boomerang_orbit_DO", "aura_mushroomcaller_set_DO", "projectile_mushroomcaller_set_DO", "aoe_mushroomcaller_set_DO", "aoe_deathcaller_death_poison_DO", "aura_frostcaller_set_DO", "projectile_frostcaller_staff_shotgun_rain_DO", "spawner_frostcaller_staff_shotgun_rain_DO", "aoe_frostcaller_staff_shotgun_rain_1_DO",
			"aoe_frostcaller_staff_shotgun_rain_2_DO", "aoe_frostcaller_staff_bow_trap_DO", "aoe_firecaller_staff_ring_orbit_DO", "aoe_firecaller_shield_break_DO", "aura_lightcaller_set_DO", "fx_stormcaller_jump_horizontal_attach_DO", "aoe_stormcaller_staff_sphere_trap_DO", "aoe_stormcaller_staff_shocker_orbit_DO", "projectile_bloodcaller_staff_shotgun_DO", "aoe_bloodcaller_death_heal_DO",
			"aoe_bloodcaller_staff_debuff_DO"
		};

		internal const bool DEBUG_LOG = false;

		private static ManualLogSource _log;

		internal static ManualLogSource Log => _log ?? (_log = Logger.CreateLogSource("PrefabOwnerBinder"));

		internal static bool IsAllowed(string prefabName)
		{
			return AllowList.Contains(prefabName);
		}

		internal static string GetPrefabName(GameObject go)
		{
			if (!Object.op_Implicit((Object)(object)go))
			{
				return string.Empty;
			}
			try
			{
				return Utils.GetPrefabName(go);
			}
			catch
			{
				string name = ((Object)go).name;
				int num = name.IndexOf('(');
				return (num > 0) ? name.Substring(0, num) : name;
			}
		}

		internal static Character ResolveOwnerCandidate(GameObject contextGO)
		{
			if (!Object.op_Implicit((Object)(object)contextGO))
			{
				return null;
			}
			Character componentInParent = contextGO.GetComponentInParent<Character>();
			if ((Object)(object)componentInParent != (Object)null)
			{
				return componentInParent;
			}
			Projectile componentInParent2 = contextGO.GetComponentInParent<Projectile>();
			if ((Object)(object)componentInParent2 != (Object)null && (Object)(object)componentInParent2.m_owner != (Object)null)
			{
				return componentInParent2.m_owner;
			}
			return (Character)(object)Player.m_localPlayer;
		}

		internal static string OwnerSourceTag(GameObject contextGO)
		{
			if (!Object.op_Implicit((Object)(object)contextGO))
			{
				return "None";
			}
			if ((Object)(object)contextGO.GetComponentInParent<Character>() != (Object)null)
			{
				return "ParentCharacter";
			}
			Projectile componentInParent = contextGO.GetComponentInParent<Projectile>();
			if ((Object)(object)componentInParent != (Object)null && (Object)(object)componentInParent.m_owner != (Object)null)
			{
				return "ProjectileOwner";
			}
			return "LocalPlayer";
		}
	}
	[HarmonyPatch(typeof(ZNetView), "Awake")]
	internal static class PrefabOwnerBinder_ZNetView_Awake
	{
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
		private static void Postfix(ZNetView __instance)
		{
			if ((Object)(object)__instance == (Object)null)
			{
				return;
			}
			GameObject gameObject = ((Component)__instance).gameObject;
			string prefabName = PrefabOwnerBinderConfig.GetPrefabName(gameObject);
			if (!PrefabOwnerBinderConfig.IsAllowed(prefabName) || !__instance.IsOwner())
			{
				return;
			}
			Character val = PrefabOwnerBinderConfig.ResolveOwnerCandidate(gameObject);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			ZDO zDO = __instance.GetZDO();
			if (zDO != null)
			{
				zDO.SetOwner(ZDOMan.GetSessionID());
			}
			int num = 0;
			int num2 = 0;
			Aoe[] componentsInChildren = gameObject.GetComponentsInChildren<Aoe>(true);
			foreach (Aoe val2 in componentsInChildren)
			{
				if ((Object)(object)val2 != (Object)null && (Object)(object)val2.m_owner == (Object)null)
				{
					val2.m_owner = val;
					num++;
				}
			}
			Projectile[] componentsInChildren2 = gameObject.GetComponentsInChildren<Projectile>(true);
			foreach (Projectile val3 in componentsInChildren2)
			{
				if ((Object)(object)val3 != (Object)null && (Object)(object)val3.m_owner == (Object)null)
				{
					val3.m_owner = val;
					num2++;
				}
			}
		}
	}
	[HarmonyPatch(typeof(Aoe), "Awake")]
	internal static class PrefabOwnerBinder_Aoe_Awake
	{
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
		private static void Postfix(Aoe __instance)
		{
			if ((Object)(object)__instance == (Object)null || (Object)(object)__instance.m_owner != (Object)null)
			{
				return;
			}
			GameObject gameObject = ((Component)__instance).gameObject;
			ZNetView component = gameObject.GetComponent<ZNetView>();
			string prefabName = PrefabOwnerBinderConfig.GetPrefabName(gameObject);
			if (PrefabOwnerBinderConfig.IsAllowed(prefabName))
			{
				if ((Object)(object)component != (Object)null && component.IsOwner())
				{
					Character val = PrefabOwnerBinderConfig.ResolveOwnerCandidate(gameObject);
					if ((Object)(object)val != (Object)null)
					{
						__instance.m_owner = val;
					}
				}
				return;
			}
			ZNetView componentInParent = gameObject.GetComponentInParent<ZNetView>();
			if (!((Object)(object)componentInParent != (Object)null) || !componentInParent.IsOwner())
			{
				return;
			}
			string prefabName2 = PrefabOwnerBinderConfig.GetPrefabName(((Component)componentInParent).gameObject);
			if (PrefabOwnerBinderConfig.IsAllowed(prefabName2))
			{
				Character val2 = PrefabOwnerBinderConfig.ResolveOwnerCandidate(gameObject);
				if ((Object)(object)val2 != (Object)null)
				{
					__instance.m_owner = val2;
				}
			}
		}
	}
	[HarmonyPatch(typeof(Projectile), "Awake")]
	internal static class PrefabOwnerBinder_Projectile_Awake
	{
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
		private static void Postfix(Projectile __instance)
		{
			if ((Object)(object)__instance == (Object)null || (Object)(object)__instance.m_owner != (Object)null)
			{
				return;
			}
			GameObject gameObject = ((Component)__instance).gameObject;
			ZNetView component = gameObject.GetComponent<ZNetView>();
			string prefabName = PrefabOwnerBinderConfig.GetPrefabName(gameObject);
			if (PrefabOwnerBinderConfig.IsAllowed(prefabName))
			{
				if ((Object)(object)component != (Object)null && component.IsOwner())
				{
					Character val = PrefabOwnerBinderConfig.ResolveOwnerCandidate(gameObject);
					if ((Object)(object)val != (Object)null)
					{
						__instance.m_owner = val;
					}
				}
				return;
			}
			ZNetView componentInParent = gameObject.GetComponentInParent<ZNetView>();
			if (!((Object)(object)componentInParent != (Object)null) || !componentInParent.IsOwner())
			{
				return;
			}
			string prefabName2 = PrefabOwnerBinderConfig.GetPrefabName(((Component)componentInParent).gameObject);
			if (PrefabOwnerBinderConfig.IsAllowed(prefabName2))
			{
				Character val2 = PrefabOwnerBinderConfig.ResolveOwnerCandidate(gameObject);
				if ((Object)(object)val2 != (Object)null)
				{
					__instance.m_owner = val2;
				}
			}
		}
	}
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[HarmonyPatch]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	public static class StatusEffectRegister
	{
		private static readonly ManualLogSource Log = Logger.CreateLogSource("StatusEffectRegister");

		private const bool ENABLE_LOGS = false;

		private const string ASSET_BUNDLE_NAME = "magic_supremacy";

		private static readonly List<string> SE_NAMES = new List<string>
		{
			"SE_Inspiration_DO", "SE_InspirationTrinket_DO", "SE_MoonCookieRiko_DO", "SE_SunCookieRiko_DO", "SE_TotemSlow_DO", "SE_TotemBuff_DO", "SE_TotemcallerShield_DO", "SE_TotemcallerOrbit_DO", "SE_MushroomcallerSlow_DO", "SE_DeathcallerDeathTrigger_DO",
			"SE_DeathcallerDebuff_DO", "SE_FrostcallerAura_DO", "SE_StonecallerArmor_DO", "SE_StonecallerShield_DO", "SE_FirecallerOrbit_DO", "SE_FirecallerShield_DO", "SE_WindcallerShield_DO", "SE_WindcallerPetal_DO", "SE_LightcallerAura_DO", "SE_LightcallerHeal_DO",
			"SE_LightcallerSigil_DO", "SE_StormcallerOrbit_DO", "SE_BloodcallerHeal_DO", "SE_BloodDebuff_DO", "SE_BloodBuff_DO", "SE_BloodcallerDeathTrigger_DO", "SE_BloodcallerDeathHeal_DO", "SE_EitrWellBuff_DO", "SE_BloodFountainBuff_DO"
		};

		[HarmonyPatch(typeof(ObjectDB), "Awake")]
		[HarmonyPostfix]
		public static void ObjectDB_Awake_Postfix(ObjectDB __instance)
		{
			if ((Object)(object)__instance == (Object)null)
			{
				return;
			}
			HashSet<int> hashSet = new HashSet<int>();
			if (__instance.m_StatusEffects != null)
			{
				for (int i = 0; i < __instance.m_StatusEffects.Count; i++)
				{
					StatusEffect val = __instance.m_StatusEffects[i];
					if (Object.op_Implicit((Object)(object)val))
					{
						hashSet.Add(StringExtensionMethods.GetStableHashCode(((Object)val).name));
					}
				}
			}
			AssetBundle val2 = null;
			try
			{
				val2 = PrefabManager.RegisterAssetBundle("magic_supremacy");
			}
			catch (Exception arg)
			{
				LogWarning(string.Format("[SERegister] Failed to register/get bundle '{0}': {1}", "magic_supremacy", arg));
			}
			int num = 0;
			int num2 = 0;
			for (int j = 0; j < SE_NAMES.Count; j++)
			{
				string text = SE_NAMES[j];
				int stableHashCode = StringExtensionMethods.GetStableHashCode(text);
				if (hashSet.Contains(stableHashCode))
				{
					num2++;
					continue;
				}
				StatusEffect val3 = null;
				try
				{
					val3 = __instance.GetStatusEffect(stableHashCode);
				}
				catch (Exception)
				{
				}
				if (!Object.op_Implicit((Object)(object)val3) && (Object)(object)val2 != (Object)null)
				{
					try
					{
						val3 = val2.LoadAsset<StatusEffect>(text);
					}
					catch (Exception arg2)
					{
						LogWarning(string.Format("[SERegister] Load '{0}' from bundle '{1}' failed: {2}", text, "magic_supremacy", arg2));
					}
				}
				if (!Object.op_Implicit((Object)(object)val3))
				{
					try
					{
						StatusEffect[] array = Resources.FindObjectsOfTypeAll<StatusEffect>();
						foreach (StatusEffect val4 in array)
						{
							if (Object.op_Implicit((Object)(object)val4) && string.Equals(((Object)val4).name, text, StringComparison.OrdinalIgnoreCase))
							{
								val3 = val4;
								break;
							}
						}
					}
					catch (Exception arg3)
					{
						LogWarning($"[SERegister] Resources scan failed for '{text}': {arg3}");
					}
				}
				if (!Object.op_Implicit((Object)(object)val3))
				{
					LogWarning("[SERegister] Not found: '" + text + "' (ObjectDB + bundle + resources). AOE/Projectile by name will NOT see it.");
					continue;
				}
				__instance.m_StatusEffects.Add(val3);
				hashSet.Add(stableHashCode);
				num++;
				LogInfo("[SERegister] Registered SE '" + text + "' into ObjectDB.");
			}
			LogInfo($"[SERegister] Done. Added={num}, Skipped={num2}, TotalInDB={__instance.m_StatusEffects?.Count ?? 0}.");
		}

		private static void LogInfo(string message)
		{
		}

		private static void LogWarning(string message)
		{
		}
	}
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[BepInPlugin("Dreanegade.Magic_Supremacy", "Magic_Supremacy", "3.0.6")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	public class Magic_SupremacyPlugin : BaseUnityPlugin
	{
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		public enum Toggle
		{
			On = 1,
			Off = 0
		}

		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		private class ConfigurationManagerAttributes
		{
			[UsedImplicitly]
			public int? Order;

			[UsedImplicitly]
			public bool? Browsable;

			[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)]
			[UsedImplicitly]
			public string Category;

			[UsedImplicitly]
			[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(new byte[] { 2, 1 })]
			public Action<ConfigEntryBase> CustomDrawer;
		}

		internal const string ModName = "Magic_Supremacy";

		internal const string ModVersion = "3.0.6";

		internal const string Author = "Dreanegade";

		private const string ModGUID = "Dreanegade.Magic_Supremacy";

		private static string ConfigFileName = "Dreanegade.Magic_Supremacy.cfg";

		private static string ConfigFileFullPath;

		internal static string ConnectionError;

		private readonly Harmony _harmony = new Harmony("Dreanegade.Magic_Supremacy");

		public static AssetBundle MainAssetBundle;

		public static readonly Dictionary<string, Sprite> PinSprites;

		internal static bool EnableGeneratedConfigs;

		private ConfigEntry<Toggle> _enableGeneratedConfigs;

		public static readonly ManualLogSource Magic_SupremacyLogger;

		private static readonly ConfigSync ConfigSync;

		private static ConfigEntry<Toggle> _serverConfigLocked;

		private static ConfigEntry<Toggle> _recipeIsActiveConfig;

		public void Awake()
		{
			DeleteFolder.Run();
			Localizer.Load();
			_serverConfigLocked = config("General", "Lock Configuration", Toggle.On, "If on, the configuration is locked and can be changed by server admins only.");
			ConfigSync.AddLockingConfigEntry<Toggle>(_serverConfigLocked);
			_enableGeneratedConfigs = ((BaseUnityPlugin)this).Config.Bind<Toggle>("General", "Enable Generated Configs", Toggle.Off, "Enables generated configuration entries for items and build pieces. Disabled by default to reduce game startup time and simplify updates. Enable if you want to customize item or build piece settings. Requires game restart.");
			EnableGeneratedConfigs = _enableGeneratedConfigs.Value == Toggle.On;
			AssetBundle val = (MainAssetBundle = PrefabManager.RegisterAssetBundle("magic_supremacy"));
			InspirationSystem.Initialize(((BaseUnityPlugin)this).Config, MainAssetBundle, ConfigSync);
			InspirationSystemUI.Initialize();
			Sprite[] array = val.LoadAllAssets<Sprite>();
			foreach (Sprite val2 in array)
			{
				PinSprites[((Object)val2).name] = val2;
			}
			LivingContainerConfig.Init(((BaseUnityPlugin)this).Config, ConfigSync);
			BuildPiece.ConfigurationEnabled = EnableGeneratedConfigs;
			ConfigVersionManager.Initialize("Magic_Supremacy", "3.0.6", ((BaseUnityPlugin)this).Config, ApplyAllConfigValuesAfterReset);
			CustomSlotSystem.Initialize();
			PrefabManager.RegisterPrefab(val, "sfx_inspiration_gain_DO");
			PrefabManager.RegisterPrefab(val, "fx_inspiration_trinket_DO");
			PrefabManager.RegisterPrefab(val, "vfx_blood_fountain_swirl_DO");
			PrefabManager.RegisterPrefab(val, "vfx_eitr_well_swirl_DO");
			PrefabManager.RegisterPrefab(val, "vfx_potion_eitr_consume_DO");
			PrefabManager.RegisterPrefab(val, "vfx_cookie_riko_consume_DO");
			PrefabManager.RegisterPrefab(val, "sfx_chest_spirit_open_DO");
			PrefabManager.RegisterPrefab(val, "sfx_chest_spirit_close_DO");
			PrefabManager.RegisterPrefab(val, "sfx_chest_void_open_DO");
			PrefabManager.RegisterPrefab(val, "aura_totemcaller_set_DO");
			PrefabManager.RegisterPrefab(val, "aoe_totemcaller_shield_break_DO");
			PrefabManager.RegisterPrefab(val, "aoe_totemcaller_staff_buff_DO");
			PrefabManager.RegisterPrefab(val, "vfx_totemcaller_staff_buff_head_DO");
			PrefabManager.RegisterPrefab(val, "fx_totemcaller_staff_buff_start_DO");
			PrefabManager.RegisterPrefab(val, "projectile_totemcaller_staff_buff_DO");
			PrefabManager.RegisterPrefab(val, "aoe_totemcaller_staff_pull_DO");
			PrefabManager.RegisterPrefab(val, "fx_totemcaller_staff_pull_start_DO");
			PrefabManager.RegisterPrefab(val, "sfx_totemcaller_staff_pull_wave_DO");
			PrefabManager.RegisterPrefab(val, "projectile_totemcaller_staff_pull_DO");
			PrefabManager.RegisterPrefab(val, "projectile_totemcaller_boomerang_DO");
			PrefabManager.RegisterPrefab(val, "vfx_totemcaller_boomerang_hit_DO");
			PrefabManager.RegisterPrefab(val, "sfx_totemcaller_boomerang_fire_DO");
			PrefabManager.RegisterPrefab(val, "aoe_totemcaller_staff_boomerang_orbit_empty_DO");
			PrefabManager.RegisterPrefab(val, "aoe_totemcaller_staff_boomerang_orbit_DO");
			PrefabManager.RegisterPrefab(val, "sfx_totemcaller_staff_boomerang_orbit_start_DO");
			PrefabManager.RegisterPrefab(val, "sfx_totemcaller_staff_boomerang_orbit_hit_DO");
			PrefabManager.RegisterPrefab(val, "aura_mushroomcaller_set_DO");
			PrefabManager.RegisterPrefab(val, "projectile_mushroomcaller_set_DO");
			PrefabManager.RegisterPrefab(val, "aoe_mushroomcaller_set_DO");
			PrefabManager.RegisterPrefab(val, "sfx_mushroomcaller_staff_fire_DO");
			PrefabManager.RegisterPrefab(val, "aoe_mushroomcaller_staff_trap_DO");
			PrefabManager.RegisterPrefab(val, "fx_mushroomcaller_staff_trap_hit_DO");
			PrefabManager.RegisterPrefab(val, "projectile_mushroomcaller_staff_trap_DO");
			PrefabManager.RegisterPrefab(val, "fx_mushroomcaller_staff_trap_land_DO");
			PrefabManager.RegisterPrefab(val, "aoe_mushroomcaller_staff_light_DO");
			PrefabManager.RegisterPrefab(val, "projectile_mushroomcaller_staff_light_DO");
			PrefabManager.RegisterPrefab(val, "fx_mushroomcaller_staff_light_land_DO");
			PrefabManager.RegisterPrefab(val, "aura_deathcaller_set_DO");
			PrefabManager.RegisterPrefab(val, "aoe_deathcaller_death_poison_DO");
			PrefabManager.RegisterPrefab(val, "vfx_deathcaller_death_trigger_head_DO");
			PrefabManager.RegisterPrefab(val, "projectile_deathcaller_staff_blaster_DO");
			PrefabManager.RegisterPrefab(val, "sfx_deathcaller_staff_blaster_DO");
			PrefabManager.RegisterPrefab(val, "fx_deathcaller_staff_blaster_hit_DO");
			PrefabManager.RegisterPrefab(val, "projectile_deathcaller_staff_shotgun_DO");
			PrefabManager.RegisterPrefab(val, "fx_deathcaller_staff_shotgun_fire_DO");
			PrefabManager.RegisterPrefab(val, "fx_deathcaller_debuff_poison_DO");
			PrefabManager.RegisterPrefab(val, "aoe_deathcaller_staff_shotgun_DO");
			PrefabManager.RegisterPrefab(val, "aura_frostcaller_set_DO");
			PrefabManager.RegisterPrefab(val, "fx_frostcaller_aura_slow_DO");
			PrefabManager.RegisterPrefab(val, "projectile_frostcaller_staff_shotgun_DO");
			PrefabManager.RegisterPrefab(val, "sfx_frostcaller_staff_shotgun_DO");
			PrefabManager.RegisterPrefab(val, "vfx_ice_shotgun_fire");
			PrefabManager.RegisterPrefab(val, "fx_frostcaller_staff_shard_hit_DO");
			PrefabManager.RegisterPrefab(val, "projectile_frostcaller_staff_shotgun_rain_empty_DO");
			PrefabManager.RegisterPrefab(val, "projectile_frostcaller_staff_shotgun_rain_DO");
			PrefabManager.RegisterPrefab(val, "spawner_frostcaller_staff_shotgun_rain_DO");
			PrefabManager.RegisterPrefab(val, "aoe_frostcaller_staff_shotgun_rain_1_DO");
			PrefabManager.RegisterPrefab(val, "aoe_frostcaller_staff_shotgun_rain_2_DO");
			PrefabManager.RegisterPrefab(val, "fx_frostcaller_staff_shotgun_rain_start_DO");
			PrefabManager.RegisterPrefab(val, "sfx_frostcaller_crystal_hit_DO");
			PrefabManager.RegisterPrefab(val, "fx_frostcaller_crystal_destruction_DO");
			PrefabManager.RegisterPrefab(val, "sfx_frostcaller_bow_equip_DO");
			PrefabManager.RegisterPrefab(val, "projectile_frostcaller_staff_bow_DO");
			PrefabManager.RegisterPrefab(val, "fx_frostcaller_bow_shot_DO");
			PrefabManager.RegisterPrefab(val, "sfx_frostcaller_bow_draw_DO");
			PrefabManager.RegisterPrefab(val, "projectile_frostcaller_staff_bow_trap_DO");
			PrefabManager.RegisterPrefab(val, "aoe_frostcaller_staff_bow_trap_DO");
			PrefabManager.RegisterPrefab(val, "fx_frostcaller_staff_bow_trap_hit_DO");
			PrefabManager.RegisterPrefab(val, "fx_frostcaller_staff_bow_trap_land_DO");
			PrefabManager.RegisterPrefab(val, "aura_stonecaller_set_DO");
			PrefabManager.RegisterPrefab(val, "fx_stonecaller_shield_break_DO");
			PrefabManager.RegisterPrefab(val, "sfx_stonecaller_shield_hit_DO");
			PrefabManager.RegisterPrefab(val, "projectile_stonecaller_staff_burst_DO");
			PrefabManager.RegisterPrefab(val, "fx_stonecaller_staff_burst_fire_DO");
			PrefabManager.RegisterPrefab(val, "vfx_stonecaller_staff_burst_hit_DO");
			PrefabManager.RegisterPrefab(val, "sfx_stonecaller_staff_burst_hit_DO");
			PrefabManager.RegisterPrefab(val, "fx_stonecaller_staff_wall_DO");
			PrefabManager.RegisterPrefab(val, "vfx_stonecaller_staff_wall_hit_DO");
			PrefabManager.RegisterPrefab(val, "sfx_stonecaller_staff_wall_hit_DO");
			PrefabManager.RegisterPrefab(val, "sfx_stonecaller_wall_hit_DO");
			PrefabManager.RegisterPrefab(val, "sfx_stonecaller_wall_destroyed_DO");
			PrefabManager.RegisterPrefab(val, "aura_firecaller_set_DO");
			PrefabManager.RegisterPrefab(val, "aoe_firecaller_shield_break_DO");
			PrefabManager.RegisterPrefab(val, "aoe_firecaller_staff_ring_orbit_empty_DO");
			PrefabManager.RegisterPrefab(val, "aoe_firecaller_staff_ring_orbit_DO");
			PrefabManager.RegisterPrefab(val, "fx_firecaller_staff_ring_orbit_start_DO");
			PrefabManager.RegisterPrefab(val, "sfx_firecaller_staff_orbit_hit_DO");
			PrefabManager.RegisterPrefab(val, "projectile_firecallercaller_staff_ring_DO");
			PrefabManager.RegisterPrefab(val, "sfx_firecaller_staff_ring_launch_DO");
			PrefabManager.RegisterPrefab(val, "projectile_firecaller_staff_blaster_DO");
			PrefabManager.RegisterPrefab(val, "sfx_firecaller_staff_blaster_shot_DO");
			PrefabManager.RegisterPrefab(val, "fx_firecallercaller_staff_blaster_hit_DO");
			PrefabManager.RegisterPrefab(val, "projectile_firecaller_staff_thrower_DO");
			PrefabManager.RegisterPrefab(val, "fx_firecaller_staff_thrower_DO");
			PrefabManager.RegisterPrefab(val, "aura_windcaller_set_DO");
			PrefabManager.RegisterPrefab(val, "fx_windcaller_jump_start_DO");
			PrefabManager.RegisterPrefab(val, "fx_windcaller_staff_petal_start_DO");
			PrefabManager.RegisterPrefab(val, "vfx_windcaller_staff_petal_back_DO");
			PrefabManager.RegisterPrefab(val, "aoe_windcaller_staff_petal_DO");
			PrefabManager.RegisterPrefab(val, "fx_windcaller_staff_shield_start_DO");
			PrefabManager.RegisterPrefab(val, "vfx_windcaller_staff_shield_sphere_DO");
			PrefabManager.RegisterPrefab(val, "fx_windcaller_staff_shield_hit_DO");
			PrefabManager.RegisterPrefab(val, "sfx_windcaller_staff_shield_break_DO");
			PrefabManager.RegisterPrefab(val, "aoe_windcaller_staff_shield_DO");
			PrefabManager.RegisterPrefab(val, "aura_lightcaller_set_DO");
			PrefabManager.RegisterPrefab(val, "aoe_lightcaller_staff_heal_DO");
			PrefabManager.RegisterPrefab(val, "fx_lightcaller_staff_heal_start_DO");
			PrefabManager.RegisterPrefab(val, "vfx_lightcaller_staff_heal_swirl_DO");
			PrefabManager.RegisterPrefab(val, "projectile_lightcaller_staff_sigil_DO");
			PrefabManager.RegisterPrefab(val, "aoe_lightcaller_staff_sigil_DO");
			PrefabManager.RegisterPrefab(val, "fx_lightcaller_staff_sigil_hit_DO");
			PrefabManager.RegisterPrefab(val, "fx_lightcaller_staff_sigil_land_DO");
			PrefabManager.RegisterPrefab(val, "projectile_lightcaller_staff_sphere_DO");
			PrefabManager.RegisterPrefab(val, "sfx_lightcaller_staff_sphere_fire_DO");
			PrefabManager.RegisterPrefab(val, "fx_lightcaller_staff_sphere_hit_DO");
			PrefabManager.RegisterPrefab(val, "projectile_lightcaller_staff_light_DO");
			PrefabManager.RegisterPrefab(val, "aoe_lightcaller_staff_light_DO");
			PrefabManager.RegisterPrefab(val, "fx_lightcaller_staff_light_land_DO");
			PrefabManager.RegisterPrefab(val, "aura_stormcaller_set_DO");
			PrefabManager.RegisterPrefab(val, "fx_stormcaller_jump_horizontal_attach_DO");
			PrefabManager.RegisterPrefab(val, "projectile_stormcaller_staff_shock_DO");
			PrefabManager.RegisterPrefab(val, "fx_stormcaller_staff_shock_DO");
			PrefabManager.RegisterPrefab(val, "aoe_stormcaller_staff_shocker_orbit_empty_DO");
			PrefabManager.RegisterPrefab(val, "aoe_stormcaller_staff_shocker_orbit_DO");
			PrefabManager.RegisterPrefab(val, "fx_stormcaller_staff_shocker_orbit_start_DO");
			PrefabManager.RegisterPrefab(val, "projectile_stormcaller_staff_sphere_DO");
			PrefabManager.RegisterPrefab(val, "sfx_stormcaller_staff_sphere_DO");
			PrefabManager.RegisterPrefab(val, "fx_stormcaller_staff_sphere_hit_DO");
			PrefabManager.RegisterPrefab(val, "projectile_stormcaller_staff_sphere_trap_DO");
			PrefabManager.RegisterPrefab(val, "aoe_stormcaller_staff_sphere_trap_DO");
			PrefabManager.RegisterPrefab(val, "fx_stormcaller_staff_sphere_trap_hit_DO");
			PrefabManager.RegisterPrefab(val, "fx_stormcaller_staff_sphere_trap_land_DO");
			PrefabManager.RegisterPrefab(val, "aura_bloodcaller_set_DO");
			PrefabManager.RegisterPrefab(val, "aoe_bloodcaller_death_heal_DO");
			PrefabManager.RegisterPrefab(val, "vfx_bloodcaller_death_trigger_head_DO");
			PrefabManager.RegisterPrefab(val, "fx_bloodcaller_death_heal_DO");
			PrefabManager.RegisterPrefab(val, "projectile_bloodcaller_staff_debuff_DO");
			PrefabManager.RegisterPrefab(val, "aoe_bloodcaller_staff_debuff_DO");
			PrefabManager.RegisterPrefab(val, "fx_bloodcaller_staff_debuff_start_DO");
			PrefabManager.RegisterPrefab(val, "vfx_bloodcaller_staff_debuff_head_DO");
			PrefabManager.RegisterPrefab(val, "fx_bloodcaller_staff_debuff_hit_DO");
			PrefabManager.RegisterPrefab(val, "projectile_bloodcaller_staff_heal_DO");
			PrefabManager.RegisterPrefab(val, "sfx_bloodcaller_staff_heal_start_DO");
			PrefabManager.RegisterPrefab(val, "sfx_bloodcaller_staff_heal_burst_DO");
			PrefabManager.RegisterPrefab(val, "fx_bloodcaller_staff_heal_hit_DO");
			PrefabManager.RegisterPrefab(val, "aoe_bloodcaller_staff_heal_buff_empty_DO");
			PrefabManager.RegisterPrefab(val, "fx_bloodcaller_staff_heal_buff_start_DO");
			PrefabManager.RegisterPrefab(val, "fx_bloodcaller_staff_heal_buff_DO");
			PrefabManager.RegisterPrefab(val, "projectile_bloodcaller_staff_shotgun_DO");
			PrefabManager.RegisterPrefab(val, "fx_bloodcaller_staff_shotgun_fire_DO");
			PrefabManager.RegisterPrefab(val, "fx_bloodcaller_staff_shotgun_hit_DO");
			PrefabManager.RegisterPrefab(val, "vfx_bloodcaller_trinket_shield_sphere_DO");
			Item item = new Item("magic_supremacy", "ArmorInspirationTrinketBlackforestDO");
			item.Crafting.Add("MagicWeaverDO", 2);
			item.RequiredItems.Add("Ruby", 1);
			item.RequiredItems.Add("Bronze", 6);
			item.RequiredItems.Add("DimEitrDO", 4);
			item.RequiredItems.Add("GreydwarfEye", 10);
			item.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item2 = new Item("magic_supremacy", "ArmorInspirationTrinketSwampDO");
			item2.Crafting.Add("MagicWeaverDO", 3);
			item2.RequiredItems.Add("ArmorInspirationTrinketBlackforestDO", 1);
			item2.RequiredItems.Add("Iron", 6);
			item2.RequiredItems.Add("DimEitrDO", 6);
			item2.RequiredItems.Add("Guck", 10);
			item2.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item2.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item3 = new Item("magic_supremacy", "ArmorInspirationTrinketMountainDO");
			item3.Crafting.Add("MagicWeaverDO", 4);
			item3.RequiredItems.Add("ArmorInspirationTrinketSwampDO", 1);
			item3.RequiredItems.Add("Silver", 6);
			item3.RequiredItems.Add("DimEitrDO", 8);
			item3.RequiredItems.Add("FreezeGland", 8);
			item3.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item3.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item4 = new Item("magic_supremacy", "ArmorInspirationTrinketPlainsDO");
			item4.Crafting.Add("MagicWeaverDO", 5);
			item4.RequiredItems.Add("ArmorInspirationTrinketMountainDO", 1);
			item4.RequiredItems.Add("BlackMetal", 6);
			item4.RequiredItems.Add("DimEitrDO", 10);
			item4.RequiredItems.Add("DragonTear", 2);
			item4.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item4.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item5 = new Item("magic_supremacy", "ArmorInspirationTrinketMistlandsDO");
			item5.Crafting.Add("MagicWeaverDO", 6);
			item5.RequiredItems.Add("ArmorInspirationTrinketPlainsDO", 1);
			item5.RequiredItems.Add("Coins", 600);
			item5.RequiredItems.Add("Eitr", 10);
			item5.RequiredItems.Add("Wisp", 4);
			item5.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item5.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item6 = new Item("magic_supremacy", "ArmorInspirationTrinketAshlandsDO");
			item6.Crafting.Add("MagicWeaverDO", 7);
			item6.RequiredItems.Add("ArmorInspirationTrinketMistlandsDO", 1);
			item6.RequiredItems.Add("FlametalNew", 6);
			item6.RequiredItems.Add("GemstoneBlue", 1);
			item6.RequiredItems.Add("GemstoneGreen", 1);
			item6.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item6.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			PrefabManager.RegisterPrefab(val, "EncounterCreatureRikoBlackforestDO");
			PrefabManager.RegisterPrefab(val, "EncounterCreatureRikoSwampDO");
			PrefabManager.RegisterPrefab(val, "EncounterCreatureRikoMountainDO");
			PrefabManager.RegisterPrefab(val, "EncounterCreatureRikoPlainsDO");
			PrefabManager.RegisterPrefab(val, "EncounterCreatureRikoMistlandsDO");
			PrefabManager.RegisterPrefab(val, "EncounterCreatureRikoAshlandsDO");
			PrefabManager.RegisterPrefab(val, "fx_riko_disappear_DO");
			MaterialReplacer.RegisterGameObjectForShaderSwap(new Item("magic_supremacy", "FoodEitrBlackforestCookieRikoDO").Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			MaterialReplacer.RegisterGameObjectForShaderSwap(new Item("magic_supremacy", "FoodEitrSwampCookieRikoDO").Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			MaterialReplacer.RegisterGameObjectForShaderSwap(new Item("magic_supremacy", "FoodEitrMountainCookieRikoDO").Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			MaterialReplacer.RegisterGameObjectForShaderSwap(new Item("magic_supremacy", "FoodEitrPlainsCookieRikoDO").Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			MaterialReplacer.RegisterGameObjectForShaderSwap(new Item("magic_supremacy", "FoodEitrMistlandsCookieRikoDO").Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			MaterialReplacer.RegisterGameObjectForShaderSwap(new Item("magic_supremacy", "FoodEitrAshlandsCookieRikoDO").Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item7 = new Item("magic_supremacy", "FoodEitrMoonCookieRikoDO");
			item7.Crafting.Add("EssenceCauldronDO", 1);
			item7.RequiredItems.Add("FoodEitrBlackforestCookieRikoDO", 1);
			item7.RequiredItems.Add("FoodEitrSwampCookieRikoDO", 1);
			item7.RequiredItems.Add("FoodEitrMountainCookieRikoDO", 1);
			item7.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item7.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item8 = new Item("magic_supremacy", "FoodEitrSunCookieRikoDO");
			item8.Crafting.Add("EssenceCauldronDO", 1);
			item8.RequiredItems.Add("FoodEitrPlainsCookieRikoDO", 1);
			item8.RequiredItems.Add("FoodEitrMistlandsCookieRikoDO", 1);
			item8.RequiredItems.Add("FoodEitrAshlandsCookieRikoDO", 1);
			item8.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item8.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece = new BuildPiece("magic_supremacy", "MagicWeaverDO");
			buildPiece.RequiredItems.Add("Bronze", 4, recover: true);
			buildPiece.RequiredItems.Add("CrystalRoseheartDO", 1, recover: true);
			buildPiece.RequiredItems.Add("DimEitrRemnantDO", 1, recover: true);
			buildPiece.RequiredItems.Add("Dandelion", 10, recover: true);
			buildPiece.Category.Set("Distant Origins");
			buildPiece.Crafting.Set(PieceManager.CraftingTable.Forge);
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece2 = new BuildPiece("magic_supremacy", "EssenceCauldronDO");
			buildPiece2.RequiredItems.Add("Bronze", 5, recover: true);
			buildPiece2.RequiredItems.Add("SpoonMouseDO", 1, recover: true);
			buildPiece2.RequiredItems.Add("Ruby", 2, recover: true);
			buildPiece2.RequiredItems.Add("DimEitrDO", 2, recover: true);
			buildPiece2.Category.Set("Distant Origins");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece2.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece3 = new BuildPiece("magic_supremacy", "MagicWeaverExt1DO");
			buildPiece3.RequiredItems.Add("Ectoplasm", 3, recover: true);
			buildPiece3.RequiredItems.Add("Stone", 30, recover: true);
			buildPiece3.RequiredItems.Add("Iron", 6, recover: true);
			buildPiece3.RequiredItems.Add("SpiritDeathDO", 3, recover: true);
			buildPiece3.Category.Set("Distant Origins");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece3.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece4 = new BuildPiece("magic_supremacy", "MagicWeaverExt2DO");
			buildPiece4.RequiredItems.Add("Crystal", 15, recover: true);
			buildPiece4.RequiredItems.Add("FineWood", 10, recover: true);
			buildPiece4.RequiredItems.Add("Silver", 6, recover: true);
			buildPiece4.RequiredItems.Add("SpiritFrostDO", 3, recover: true);
			buildPiece4.Category.Set("Distant Origins");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece4.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece5 = new BuildPiece("magic_supremacy", "MagicWeaverExt3DO");
			buildPiece5.RequiredItems.Add("PageArcaneDO", 6, recover: true);
			buildPiece5.RequiredItems.Add("FineWood", 15, recover: true);
			buildPiece5.RequiredItems.Add("LinenThread", 6, recover: true);
			buildPiece5.RequiredItems.Add("PotionEitrPlainsDO", 4, recover: true);
			buildPiece5.Category.Set("Distant Origins");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece5.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece6 = new BuildPiece("magic_supremacy", "MagicWeaverExt4DO");
			buildPiece6.RequiredItems.Add("DragonTear", 2, recover: true);
			buildPiece6.RequiredItems.Add("BlackMarble", 20, recover: true);
			buildPiece6.RequiredItems.Add("BlackMetal", 12, recover: true);
			buildPiece6.RequiredItems.Add("Eitr", 12, recover: true);
			buildPiece6.Category.Set("Distant Origins");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece6.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece7 = new BuildPiece("magic_supremacy", "MagicWeaverExt5DO");
			buildPiece7.RequiredItems.Add("GiantBloodSack", 6, recover: true);
			buildPiece7.RequiredItems.Add("Grausten", 30, recover: true);
			buildPiece7.RequiredItems.Add("FlametalNew", 6, recover: true);
			buildPiece7.RequiredItems.Add("SpiritBloodDO", 6, recover: true);
			buildPiece7.Category.Set("Distant Origins");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece7.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece8 = new BuildPiece("magic_supremacy", "HolderSpiritTotemDO");
			buildPiece8.RequiredItems.Add("SpiritTotemDO", 1, recover: true);
			buildPiece8.RequiredItems.Add("Bronze", 1, recover: true);
			buildPiece8.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece8.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece9 = new BuildPiece("magic_supremacy", "HolderSpiritMushroomDO");
			buildPiece9.RequiredItems.Add("SpiritMushroomDO", 1, recover: true);
			buildPiece9.RequiredItems.Add("Bronze", 1, recover: true);
			buildPiece9.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece9.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece10 = new BuildPiece("magic_supremacy", "HolderSpiritDeathDO");
			buildPiece10.RequiredItems.Add("SpiritDeathDO", 1, recover: true);
			buildPiece10.RequiredItems.Add("Iron", 1, recover: true);
			buildPiece10.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece10.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece11 = new BuildPiece("magic_supremacy", "HolderSpiritFrostDO");
			buildPiece11.RequiredItems.Add("SpiritFrostDO", 1, recover: true);
			buildPiece11.RequiredItems.Add("Silver", 1, recover: true);
			buildPiece11.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece11.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece12 = new BuildPiece("magic_supremacy", "HolderSpiritFireDO");
			buildPiece12.RequiredItems.Add("SpiritFireDO", 1, recover: true);
			buildPiece12.RequiredItems.Add("BlackMetal", 1, recover: true);
			buildPiece12.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece12.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece13 = new BuildPiece("magic_supremacy", "HolderSpiritStoneDO");
			buildPiece13.RequiredItems.Add("SpiritStoneDO", 1, recover: true);
			buildPiece13.RequiredItems.Add("BlackMetal", 1, recover: true);
			buildPiece13.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece13.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece14 = new BuildPiece("magic_supremacy", "HolderSpiritWindDO");
			buildPiece14.RequiredItems.Add("SpiritWindDO", 1, recover: true);
			buildPiece14.RequiredItems.Add("Iron", 1, recover: true);
			buildPiece14.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece14.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece15 = new BuildPiece("magic_supremacy", "HolderSpiritLightDO");
			buildPiece15.RequiredItems.Add("SpiritLightDO", 1, recover: true);
			buildPiece15.RequiredItems.Add("Iron", 1, recover: true);
			buildPiece15.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece15.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece16 = new BuildPiece("magic_supremacy", "HolderSpiritStormDO");
			buildPiece16.RequiredItems.Add("SpiritStormDO", 1, recover: true);
			buildPiece16.RequiredItems.Add("FlametalNew", 1, recover: true);
			buildPiece16.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece16.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece17 = new BuildPiece("magic_supremacy", "HolderSpiritBloodDO");
			buildPiece17.RequiredItems.Add("SpiritBloodDO", 1, recover: true);
			buildPiece17.RequiredItems.Add("FlametalNew", 1, recover: true);
			buildPiece17.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece17.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece18 = new BuildPiece("magic_supremacy", "ChestVoidDO");
			buildPiece18.RequiredItems.Add("BlackCore", 1, recover: true);
			buildPiece18.RequiredItems.Add("Crystal", 3, recover: true);
			buildPiece18.RequiredItems.Add("Bronze", 4, recover: true);
			buildPiece18.RequiredItems.Add("YggdrasilWood", 10, recover: true);
			buildPiece18.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece18.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece19 = new BuildPiece("magic_supremacy", "BookcaseArcaneLargeV1DO");
			buildPiece19.RequiredItems.Add("RoundLog", 30, recover: true);
			buildPiece19.RequiredItems.Add("BronzeNails", 20, recover: true);
			buildPiece19.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece19.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece20 = new BuildPiece("magic_supremacy", "BookcaseArcaneLargeV2DO");
			buildPiece20.RequiredItems.Add("RoundLog", 30, recover: true);
			buildPiece20.RequiredItems.Add("BronzeNails", 20, recover: true);
			buildPiece20.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece20.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece21 = new BuildPiece("magic_supremacy", "BookcaseArcaneMediumV1DO");
			buildPiece21.RequiredItems.Add("RoundLog", 20, recover: true);
			buildPiece21.RequiredItems.Add("BronzeNails", 10, recover: true);
			buildPiece21.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece21.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece22 = new BuildPiece("magic_supremacy", "BookcaseArcaneMediumV2DO");
			buildPiece22.RequiredItems.Add("RoundLog", 20, recover: true);
			buildPiece22.RequiredItems.Add("BronzeNails", 10, recover: true);
			buildPiece22.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece22.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece23 = new BuildPiece("magic_supremacy", "BookcaseArcaneMediumA1DO");
			buildPiece23.RequiredItems.Add("RoundLog", 20, recover: true);
			buildPiece23.RequiredItems.Add("BronzeNails", 10, recover: true);
			buildPiece23.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece23.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece24 = new BuildPiece("magic_supremacy", "BookcaseArcaneMediumA2DO");
			buildPiece24.RequiredItems.Add("RoundLog", 20, recover: true);
			buildPiece24.RequiredItems.Add("BronzeNails", 10, recover: true);
			buildPiece24.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece24.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece25 = new BuildPiece("magic_supremacy", "BookcaseArcaneSmallV1DO");
			buildPiece25.RequiredItems.Add("RoundLog", 10, recover: true);
			buildPiece25.RequiredItems.Add("BronzeNails", 5, recover: true);
			buildPiece25.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece25.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece26 = new BuildPiece("magic_supremacy", "BookcaseArcaneSmallV2DO");
			buildPiece26.RequiredItems.Add("RoundLog", 10, recover: true);
			buildPiece26.RequiredItems.Add("BronzeNails", 5, recover: true);
			buildPiece26.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece26.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece27 = new BuildPiece("magic_supremacy", "BookcaseArcaneLargeD1DO");
			buildPiece27.RequiredItems.Add("RoundLog", 30, recover: true);
			buildPiece27.RequiredItems.Add("BronzeNails", 20, recover: true);
			buildPiece27.RequiredItems.Add("DimEitrDO", 1, recover: true);
			buildPiece27.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece27.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece28 = new BuildPiece("magic_supremacy", "BookcaseArcaneLargeD2DO");
			buildPiece28.RequiredItems.Add("RoundLog", 30, recover: true);
			buildPiece28.RequiredItems.Add("BronzeNails", 20, recover: true);
			buildPiece28.RequiredItems.Add("DimEitrDO", 1, recover: true);
			buildPiece28.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece28.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece29 = new BuildPiece("magic_supremacy", "BookcaseArcaneMediumD1DO");
			buildPiece29.RequiredItems.Add("RoundLog", 20, recover: true);
			buildPiece29.RequiredItems.Add("BronzeNails", 10, recover: true);
			buildPiece29.RequiredItems.Add("DimEitrDO", 1, recover: true);
			buildPiece29.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece29.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece30 = new BuildPiece("magic_supremacy", "BookcaseArcaneMediumD2DO");
			buildPiece30.RequiredItems.Add("RoundLog", 20, recover: true);
			buildPiece30.RequiredItems.Add("BronzeNails", 10, recover: true);
			buildPiece30.RequiredItems.Add("DimEitrDO", 1, recover: true);
			buildPiece30.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece30.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece31 = new BuildPiece("magic_supremacy", "BookcaseArcaneSmallD1DO");
			buildPiece31.RequiredItems.Add("RoundLog", 10, recover: true);
			buildPiece31.RequiredItems.Add("BronzeNails", 5, recover: true);
			buildPiece31.RequiredItems.Add("DimEitrDO", 1, recover: true);
			buildPiece31.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece31.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece32 = new BuildPiece("magic_supremacy", "BookcaseArcaneSmallD2DO");
			buildPiece32.RequiredItems.Add("RoundLog", 10, recover: true);
			buildPiece32.RequiredItems.Add("BronzeNails", 5, recover: true);
			buildPiece32.RequiredItems.Add("DimEitrDO", 1, recover: true);
			buildPiece32.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece32.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece33 = new BuildPiece("magic_supremacy", "BookcaseArcaneCornerV1DO");
			buildPiece33.RequiredItems.Add("RoundLog", 4, recover: true);
			buildPiece33.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece33.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece34 = new BuildPiece("magic_supremacy", "BookcaseArcaneCornerV2DO");
			buildPiece34.RequiredItems.Add("RoundLog", 4, recover: true);
			buildPiece34.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece34.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece35 = new BuildPiece("magic_supremacy", "BookcaseArcaneCornerV3DO");
			buildPiece35.RequiredItems.Add("RoundLog", 4, recover: true);
			buildPiece35.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece35.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece36 = new BuildPiece("magic_supremacy", "BookcaseArcaneCornerV4DO");
			buildPiece36.RequiredItems.Add("RoundLog", 4, recover: true);
			buildPiece36.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece36.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece37 = new BuildPiece("magic_supremacy", "BookcaseArcaneCornerA1DO");
			buildPiece37.RequiredItems.Add("RoundLog", 4, recover: true);
			buildPiece37.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece37.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece38 = new BuildPiece("magic_supremacy", "BookcaseArcaneCornerA2DO");
			buildPiece38.RequiredItems.Add("RoundLog", 4, recover: true);
			buildPiece38.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece38.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece39 = new BuildPiece("magic_supremacy", "BookcaseArcaneLadderV1DO");
			buildPiece39.RequiredItems.Add("RoundLog", 4, recover: true);
			buildPiece39.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece39.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece40 = new BuildPiece("magic_supremacy", "TileArcaneFloorV1DO");
			buildPiece40.RequiredItems.Add("Crystal", 1, recover: true);
			buildPiece40.RequiredItems.Add("Wood", 2, recover: true);
			buildPiece40.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece40.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece41 = new BuildPiece("magic_supremacy", "TileArcaneFloorV2DO");
			buildPiece41.RequiredItems.Add("Crystal", 1, recover: true);
			buildPiece41.RequiredItems.Add("Wood", 2, recover: true);
			buildPiece41.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece41.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece42 = new BuildPiece("magic_supremacy", "TileArcaneFloorV3DO");
			buildPiece42.RequiredItems.Add("Crystal", 1, recover: true);
			buildPiece42.RequiredItems.Add("Wood", 2, recover: true);
			buildPiece42.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece42.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece43 = new BuildPiece("magic_supremacy", "TileArcaneFloorV4DO");
			buildPiece43.RequiredItems.Add("Crystal", 1, recover: true);
			buildPiece43.RequiredItems.Add("Wood", 2, recover: true);
			buildPiece43.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece43.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece44 = new BuildPiece("magic_supremacy", "TileArcaneFloorV5DO");
			buildPiece44.RequiredItems.Add("Crystal", 1, recover: true);
			buildPiece44.RequiredItems.Add("Wood", 2, recover: true);
			buildPiece44.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece44.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece45 = new BuildPiece("magic_supremacy", "TileArcaneWallV1DO");
			buildPiece45.RequiredItems.Add("Crystal", 1, recover: true);
			buildPiece45.RequiredItems.Add("Wood", 2, recover: true);
			buildPiece45.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece45.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece46 = new BuildPiece("magic_supremacy", "TileArcaneWallV2DO");
			buildPiece46.RequiredItems.Add("Crystal", 1, recover: true);
			buildPiece46.RequiredItems.Add("Wood", 2, recover: true);
			buildPiece46.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece46.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece47 = new BuildPiece("magic_supremacy", "TileArcaneWallV3DO");
			buildPiece47.RequiredItems.Add("Crystal", 1, recover: true);
			buildPiece47.RequiredItems.Add("Wood", 2, recover: true);
			buildPiece47.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece47.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece48 = new BuildPiece("magic_supremacy", "TileArcaneWallV4DO");
			buildPiece48.RequiredItems.Add("Crystal", 1, recover: true);
			buildPiece48.RequiredItems.Add("Wood", 2, recover: true);
			buildPiece48.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece48.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece49 = new BuildPiece("magic_supremacy", "TileArcaneWallV5DO");
			buildPiece49.RequiredItems.Add("Crystal", 1, recover: true);
			buildPiece49.RequiredItems.Add("Wood", 2, recover: true);
			buildPiece49.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece49.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece50 = new BuildPiece("magic_supremacy", "TileArcaneWallA1DO");
			buildPiece50.RequiredItems.Add("Crystal", 1, recover: true);
			buildPiece50.RequiredItems.Add("Wood", 2, recover: true);
			buildPiece50.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece50.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece51 = new BuildPiece("magic_supremacy", "TileArcaneWallA2DO");
			buildPiece51.RequiredItems.Add("Crystal", 1, recover: true);
			buildPiece51.RequiredItems.Add("Wood", 2, recover: true);
			buildPiece51.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece51.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece52 = new BuildPiece("magic_supremacy", "TileArcaneWallA3DO");
			buildPiece52.RequiredItems.Add("Crystal", 1, recover: true);
			buildPiece52.RequiredItems.Add("Wood", 2, recover: true);
			buildPiece52.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece52.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece53 = new BuildPiece("magic_supremacy", "TileArcaneWallA4DO");
			buildPiece53.RequiredItems.Add("Crystal", 1, recover: true);
			buildPiece53.RequiredItems.Add("Wood", 2, recover: true);
			buildPiece53.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece53.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece54 = new BuildPiece("magic_supremacy", "TileArcaneWallA5DO");
			buildPiece54.RequiredItems.Add("Crystal", 1, recover: true);
			buildPiece54.RequiredItems.Add("Wood", 2, recover: true);
			buildPiece54.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece54.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece55 = new BuildPiece("magic_supremacy", "TotemTikiWiseDO");
			buildPiece55.RequiredItems.Add("SpiritTotemDO", 1, recover: true);
			buildPiece55.RequiredItems.Add("RoundLog", 12, recover: true);
			buildPiece55.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece55.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece56 = new BuildPiece("magic_supremacy", "TotemTikiMockingDO");
			buildPiece56.RequiredItems.Add("SpiritTotemDO", 1, recover: true);
			buildPiece56.RequiredItems.Add("RoundLog", 12, recover: true);
			buildPiece56.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece56.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece57 = new BuildPiece("magic_supremacy", "TotemTikiFierceDO");
			buildPiece57.RequiredItems.Add("SpiritTotemDO", 1, recover: true);
			buildPiece57.RequiredItems.Add("RoundLog", 12, recover: true);
			buildPiece57.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece57.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			BuildPiece buildPiece58 = new BuildPiece("magic_supremacy", "CarpetFlyDO");
			buildPiece58.RequiredItems.Add("JuteRed", 2, recover: true);
			buildPiece58.RequiredItems.Add("JuteBlue", 2, recover: true);
			buildPiece58.Category.Set("Distant Origins Decor");
			MaterialReplacer.RegisterGameObjectForShaderSwap(buildPiece58.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item9 = new Item("magic_supremacy", "SpiritTotemDO");
			item9.DropsFrom.Add("Neck", 0.03f, 1, 1);
			item9.DropsFrom.Add("Boar", 0.03f, 1, 1);
			item9.DropsFrom.Add("Deer", 0.03f, 1, 2);
			item9.DropsFrom.Add("Greyling", 0.03f, 1, 1);
			item9.DropsFrom.Add("Eikthyr", 1f, 3, 6);
			item9.DropsFrom.Add("Greydwarf", 0.05f, 1, 2);
			item9.DropsFrom.Add("Greydwarf_Elite", 0.15f, 1, 3);
			item9.DropsFrom.Add("Greydwarf_Shaman", 0.15f, 1, 3);
			item9.DropsFrom.Add("Troll", 0.3f, 1, 3);
			item9.DropsFrom.Add("gd_king", 1f, 3, 6);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item9.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item10 = new Item("magic_supremacy", "SpiritMushroomDO");
			item10.DropsFrom.Add("Neck", 0.03f, 1, 1);
			item10.DropsFrom.Add("Boar", 0.03f, 1, 1);
			item10.DropsFrom.Add("Deer", 0.03f, 1, 2);
			item10.DropsFrom.Add("Greyling", 0.03f, 1, 1);
			item10.DropsFrom.Add("Eikthyr", 1f, 3, 6);
			item10.DropsFrom.Add("Greydwarf", 0.05f, 1, 2);
			item10.DropsFrom.Add("Greydwarf_Elite", 0.15f, 1, 3);
			item10.DropsFrom.Add("Greydwarf_Shaman", 0.15f, 1, 3);
			item10.DropsFrom.Add("Troll", 0.3f, 1, 3);
			item10.DropsFrom.Add("gd_king", 1f, 3, 6);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item10.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item11 = new Item("magic_supremacy", "SpiritDeathDO");
			item11.DropsFrom.Add("Draugr", 0.03f, 1, 2);
			item11.DropsFrom.Add("Draugr_Ranged", 0.03f, 1, 2);
			item11.DropsFrom.Add("Draugr_Elite", 0.1f, 2, 3);
			item11.DropsFrom.Add("Blob", 0.05f, 1, 1);
			item11.DropsFrom.Add("BlobElite", 0.15f, 1, 2);
			item11.DropsFrom.Add("Leech", 0.03f, 1, 1);
			item11.DropsFrom.Add("Wraith", 0.14f, 1, 3);
			item11.DropsFrom.Add("Abomination", 0.3f, 2, 5);
			item11.DropsFrom.Add("Bonemass", 1f, 3, 8);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item11.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item12 = new Item("magic_supremacy", "SpiritFrostDO");
			item12.DropsFrom.Add("Bat", 0.02f, 1, 1);
			item12.DropsFrom.Add("Wolf", 0.06f, 1, 2);
			item12.DropsFrom.Add("Hatchling", 0.1f, 1, 2);
			item12.DropsFrom.Add("Fenring", 0.18f, 1, 3);
			item12.DropsFrom.Add("Fenring_Cultist", 0.2f, 1, 3);
			item12.DropsFrom.Add("Ulv", 0.2f, 1, 3);
			item12.DropsFrom.Add("StoneGolem", 0.4f, 2, 5);
			item12.DropsFrom.Add("Dragon", 1f, 3, 8);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item12.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item13 = new Item("magic_supremacy", "SpiritFireDO");
			item13.DropsFrom.Add("Lox", 0.15f, 1, 2);
			item13.DropsFrom.Add("Deathsquito", 0.03f, 1, 2);
			item13.DropsFrom.Add("Goblin", 0.07f, 1, 2);
			item13.DropsFrom.Add("GoblinArcher", 0.07f, 1, 2);
			item13.DropsFrom.Add("GoblinBrute", 0.2f, 2, 3);
			item13.DropsFrom.Add("GoblinShaman", 0.15f, 2, 3);
			item13.DropsFrom.Add("BlobTar", 0.12f, 1, 3);
			item13.DropsFrom.Add("GoblinKing", 1f, 3, 8);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item13.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item14 = new Item("magic_supremacy", "SpiritStoneDO");
			item14.DropsFrom.Add("Lox", 0.15f, 1, 2);
			item14.DropsFrom.Add("Deathsquito", 0.03f, 1, 2);
			item14.DropsFrom.Add("Goblin", 0.07f, 1, 2);
			item14.DropsFrom.Add("GoblinArcher", 0.07f, 1, 2);
			item14.DropsFrom.Add("GoblinBrute", 0.2f, 2, 3);
			item14.DropsFrom.Add("GoblinShaman", 0.15f, 2, 3);
			item14.DropsFrom.Add("BlobTar", 0.12f, 1, 3);
			item14.DropsFrom.Add("GoblinKing", 1f, 3, 8);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item14.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item15 = new Item("magic_supremacy", "SpiritWindDO");
			item15.DropsFrom.Add("Hare", 0.06f, 1, 1);
			item15.DropsFrom.Add("Tick", 0.04f, 1, 2);
			item15.DropsFrom.Add("Seeker", 0.12f, 1, 2);
			item15.DropsFrom.Add("SeekerBrute", 0.3f, 1, 3);
			item15.DropsFrom.Add("Dverger", 0.12f, 1, 2);
			item15.DropsFrom.Add("DvergerMage", 0.12f, 1, 2);
			item15.DropsFrom.Add("Gjall", 0.4f, 2, 5);
			item15.DropsFrom.Add("SeekerQueen", 1f, 4, 8);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item15.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item16 = new Item("magic_supremacy", "SpiritLightDO");
			item16.DropsFrom.Add("Hare", 0.06f, 1, 1);
			item16.DropsFrom.Add("Tick", 0.04f, 1, 2);
			item16.DropsFrom.Add("Seeker", 0.12f, 1, 2);
			item16.DropsFrom.Add("SeekerBrute", 0.3f, 1, 3);
			item16.DropsFrom.Add("Dverger", 0.12f, 1, 2);
			item16.DropsFrom.Add("DvergerMage", 0.12f, 1, 2);
			item16.DropsFrom.Add("Gjall", 0.4f, 2, 5);
			item16.DropsFrom.Add("SeekerQueen", 1f, 4, 8);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item16.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item17 = new Item("magic_supremacy", "SpiritStormDO");
			item17.DropsFrom.Add("Volture", 0.05f, 1, 2);
			item17.DropsFrom.Add("BlobLava", 0.08f, 1, 2);
			item17.DropsFrom.Add("Charred_Twitcher", 0.08f, 1, 2);
			item17.DropsFrom.Add("Charred_Melee", 0.1f, 1, 2);
			item17.DropsFrom.Add("Charred_Archer", 0.1f, 1, 2);
			item17.DropsFrom.Add("Charred_Mage", 0.15f, 1, 2);
			item17.DropsFrom.Add("Asksvin", 0.12f, 1, 2);
			item17.DropsFrom.Add("BonemawSerpent", 0.2f, 1, 2);
			item17.DropsFrom.Add("Morgen", 0.2f, 1, 2);
			item17.DropsFrom.Add("FallenValkyrie", 0.3f, 1, 2);
			item17.DropsFrom.Add("Fader", 1f, 4, 8);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item17.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item18 = new Item("magic_supremacy", "SpiritBloodDO");
			item18.DropsFrom.Add("Volture", 0.05f, 1, 2);
			item18.DropsFrom.Add("BlobLava", 0.08f, 1, 2);
			item18.DropsFrom.Add("Charred_Twitcher", 0.08f, 1, 2);
			item18.DropsFrom.Add("Charred_Melee", 0.1f, 1, 2);
			item18.DropsFrom.Add("Charred_Archer", 0.1f, 1, 2);
			item18.DropsFrom.Add("Charred_Mage", 0.15f, 1, 2);
			item18.DropsFrom.Add("Asksvin", 0.12f, 1, 2);
			item18.DropsFrom.Add("BonemawSerpent", 0.2f, 1, 2);
			item18.DropsFrom.Add("Morgen", 0.2f, 1, 2);
			item18.DropsFrom.Add("FallenValkyrie", 0.3f, 1, 2);
			item18.DropsFrom.Add("Fader", 1f, 4, 8);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item18.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item19 = new Item("magic_supremacy", "DimEitrDO");
			item19.Crafting.Add("MagicWeaverDO", 1);
			item19.RequiredItems.Add("DimEitrRemnantDO", 1);
			item19.RequiredItems.Add("SurtlingCore", 1);
			item19.RequiredItems.Add("GreydwarfEye", 3);
			item19.CraftAmount = 2;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item19.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item20 = new Item("magic_supremacy", "DimEitrRemnantDO");
			item20.DropsFrom.Add("Greyling", 0.05f, 1, 2);
			item20.DropsFrom.Add("Boar", 0.05f, 1, 2);
			item20.DropsFrom.Add("Deer", 0.05f, 1, 1);
			item20.DropsFrom.Add("Neck", 0.07f, 1, 2);
			item20.DropsFrom.Add("Skeleton", 0.05f, 1, 2);
			item20.DropsFrom.Add("Skeleton_Poison", 0.4f, 1, 4);
			item20.DropsFrom.Add("Ghost", 0.1f, 1, 3);
			item20.DropsFrom.Add("Greydwarf", 0.05f, 1, 2);
			item20.DropsFrom.Add("Greydwarf_Elite", 0.15f, 1, 3);
			item20.DropsFrom.Add("Greydwarf_Shaman", 0.15f, 1, 3);
			item20.DropsFrom.Add("Troll", 0.25f, 1, 3);
			item20.DropsFrom.Add("Leech", 0.05f, 1, 1);
			item20.DropsFrom.Add("Blob", 0.08f, 1, 1);
			item20.DropsFrom.Add("BlobElite", 0.1f, 1, 2);
			item20.DropsFrom.Add("Draugr", 0.07f, 1, 1);
			item20.DropsFrom.Add("Draugr_Ranged", 0.07f, 1, 1);
			item20.DropsFrom.Add("Draugr_Elite", 0.15f, 1, 2);
			item20.DropsFrom.Add("Surtling", 0.02f, 1, 1);
			item20.DropsFrom.Add("Wraith", 0.2f, 1, 2);
			item20.DropsFrom.Add("Abomination", 0.4f, 2, 4);
			item20.DropsFrom.Add("Bat", 0.03f, 1, 1);
			item20.DropsFrom.Add("Wolf", 0.09f, 1, 2);
			item20.DropsFrom.Add("Hatchling", 0.11f, 1, 1);
			item20.DropsFrom.Add("Fenring", 0.15f, 1, 2);
			item20.DropsFrom.Add("Fenring_Cultist", 0.2f, 1, 2);
			item20.DropsFrom.Add("Ulv", 0.2f, 1, 2);
			item20.DropsFrom.Add("StoneGolem", 0.4f, 3, 5);
			item20.DropsFrom.Add("Lox", 0.12f, 1, 2);
			item20.DropsFrom.Add("Deathsquito", 0.06f, 1, 2);
			item20.DropsFrom.Add("Goblin", 0.07f, 1, 2);
			item20.DropsFrom.Add("GoblinArcher", 0.08f, 1, 2);
			item20.DropsFrom.Add("GoblinBrute", 0.25f, 2, 3);
			item20.DropsFrom.Add("GoblinShaman", 0.25f, 2, 3);
			item20.DropsFrom.Add("BlobTar", 0.15f, 1, 3);
			item20.DropsFrom.Add("Skeleton_Hildir", 1f, 2, 4);
			item20.DropsFrom.Add("Fenring_Cultist_Hildir", 1f, 3, 5);
			item20.DropsFrom.Add("GoblinBruteBros", 1f, 3, 7);
			item20.DropsFrom.Add("GoblinBrute_Hildir", 1f, 3, 7);
			item20.DropsFrom.Add("GoblinShaman_Hildir", 1f, 3, 7);
			item20.DropsFrom.Add("Eikthyr", 0.6f, 2, 5);
			item20.DropsFrom.Add("gd_king", 0.7f, 3, 6);
			item20.DropsFrom.Add("Bonemass", 0.8f, 4, 7);
			item20.DropsFrom.Add("Dragon", 0.9f, 5, 8);
			item20.DropsFrom.Add("GoblinKing", 1f, 6, 10);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item20.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item21 = new Item("magic_supremacy", "CrystalRoseheartDO");
			item21.DropsFrom.Add("Eikthyr", 1f, 1, 1);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item21.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item22 = new Item("magic_supremacy", "PageArcaneDO");
			item22.Trade.RequiredGlobalKey = "defeated_eikthyr";
			item22.Trade.Trader = Trader.Haldor;
			item22.Trade.Price = 200u;
			item22.CraftAmount = 1;
			item22.DropsFrom.Add("Greyling", 0.001f, 1, 2);
			item22.DropsFrom.Add("Boar", 0.01f, 1, 2);
			item22.DropsFrom.Add("Deer", 0.01f, 1, 2);
			item22.DropsFrom.Add("Neck", 0.01f, 1, 2);
			item22.DropsFrom.Add("Skeleton", 0.005f, 1, 2);
			item22.DropsFrom.Add("Skeleton_Poison", 0.02f, 1, 2);
			item22.DropsFrom.Add("Ghost", 0.02f, 1, 2);
			item22.DropsFrom.Add("Greydwarf", 0.005f, 1, 2);
			item22.DropsFrom.Add("Greydwarf_Elite", 0.005f, 1, 2);
			item22.DropsFrom.Add("Greydwarf_Shaman", 0.005f, 1, 2);
			item22.DropsFrom.Add("Troll", 0.08f, 1, 2);
			item22.DropsFrom.Add("Leech", 0.01f, 1, 2);
			item22.DropsFrom.Add("Blob", 0.01f, 1, 2);
			item22.DropsFrom.Add("BlobElite", 0.03f, 1, 2);
			item22.DropsFrom.Add("Draugr", 0.001f, 1, 2);
			item22.DropsFrom.Add("Draugr_Ranged", 0.001f, 1, 2);
			item22.DropsFrom.Add("Draugr_Elite", 0.01f, 1, 2);
			item22.DropsFrom.Add("Surtling", 0.001f, 1, 2);
			item22.DropsFrom.Add("Wraith", 0.03f, 1, 2);
			item22.DropsFrom.Add("Abomination", 0.1f, 1, 2);
			item22.DropsFrom.Add("Bat", 0.001f, 1, 2);
			item22.DropsFrom.Add("Wolf", 0.015f, 1, 2);
			item22.DropsFrom.Add("Hatchling", 0.02f, 1, 2);
			item22.DropsFrom.Add("Fenring", 0.03f, 1, 2);
			item22.DropsFrom.Add("Fenring_Cultist", 0.04f, 1, 2);
			item22.DropsFrom.Add("Ulv", 0.04f, 1, 2);
			item22.DropsFrom.Add("StoneGolem", 0.1f, 1, 2);
			item22.DropsFrom.Add("Lox", 0.03f, 1, 2);
			item22.DropsFrom.Add("Deathsquito", 0.01f, 1, 2);
			item22.DropsFrom.Add("Goblin", 0.01f, 1, 2);
			item22.DropsFrom.Add("GoblinArcher", 0.01f, 1, 2);
			item22.DropsFrom.Add("GoblinBrute", 0.05f, 1, 2);
			item22.DropsFrom.Add("GoblinShaman", 0.1f, 1, 2);
			item22.DropsFrom.Add("BlobTar", 0.03f, 1, 2);
			item22.DropsFrom.Add("Tick", 0.01f, 1, 2);
			item22.DropsFrom.Add("Seeker", 0.03f, 1, 2);
			item22.DropsFrom.Add("Seeker_Brood", 0.005f, 1, 2);
			item22.DropsFrom.Add("SeekerBrute", 0.1f, 1, 2);
			item22.DropsFrom.Add("Gjall", 0.2f, 1, 2);
			item22.DropsFrom.Add("Volture", 0.01f, 1, 2);
			item22.DropsFrom.Add("BlobLava", 0.01f, 1, 2);
			item22.DropsFrom.Add("Charred_Twitcher", 0.02f, 1, 2);
			item22.DropsFrom.Add("Charred_Melee", 0.02f, 1, 2);
			item22.DropsFrom.Add("Charred_Archer", 0.02f, 1, 2);
			item22.DropsFrom.Add("Charred_Mage", 0.1f, 1, 2);
			item22.DropsFrom.Add("Asksvin", 0.02f, 1, 2);
			item22.DropsFrom.Add("BonemawSerpent", 0.15f, 1, 2);
			item22.DropsFrom.Add("Morgen", 0.1f, 1, 2);
			item22.DropsFrom.Add("FallenValkyrie", 0.15f, 1, 2);
			item22.DropsFrom.Add("Skeleton_Hildir", 0.2f, 1, 3);
			item22.DropsFrom.Add("Fenring_Cultist_Hildir", 0.2f, 1, 3);
			item22.DropsFrom.Add("GoblinBruteBros", 0.2f, 1, 3);
			item22.DropsFrom.Add("GoblinBrute_Hildir", 0.2f, 1, 3);
			item22.DropsFrom.Add("GoblinShaman_Hildir", 0.2f, 1, 3);
			item22.DropsFrom.Add("Eikthyr", 0.15f, 1, 3);
			item22.DropsFrom.Add("gd_king", 0.2f, 1, 3);
			item22.DropsFrom.Add("Bonemass", 0.2f, 1, 3);
			item22.DropsFrom.Add("Dragon", 0.3f, 1, 4);
			item22.DropsFrom.Add("GoblinKing", 0.3f, 1, 4);
			item22.DropsFrom.Add("SeekerQueen", 0.4f, 1, 5);
			item22.DropsFrom.Add("Fader", 0.4f, 1, 5);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item22.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item23 = new Item("magic_supremacy", "SpoonMouseDO");
			item23.Trade.Price = 30u;
			item23.DropsFrom.Add("Troll", 0.5f, 1, 1);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item23.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item24 = new Item("magic_supremacy", "FoodEitrBlackForestDessertDO");
			item24.Crafting.Add("EssenceCauldronDO", 1);
			item24.RequiredItems.Add("Blueberries", 5);
			item24.RequiredItems.Add("Honey", 3);
			item24.RequiredItems.Add("Carrot", 4);
			item24.CraftAmount = 2;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item24.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item25 = new Item("magic_supremacy", "FoodEitrBlackForestDrinkDO");
			item25.Crafting.Add("EssenceCauldronDO", 1);
			item25.RequiredItems.Add("Blueberries", 4);
			item25.RequiredItems.Add("Thistle", 3);
			item25.RequiredItems.Add("MushroomYellow", 4);
			item25.CraftAmount = 2;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item25.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item26 = new Item("magic_supremacy", "FoodEitrSwampDessertDO");
			item26.Crafting.Add("EssenceCauldronDO", 1);
			item26.RequiredItems.Add("Ooze", 4);
			item26.RequiredItems.Add("Honey", 5);
			item26.RequiredItems.Add("Turnip", 4);
			item26.CraftAmount = 2;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item26.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item27 = new Item("magic_supremacy", "FoodEitrSwampDrinkDO");
			item27.Crafting.Add("EssenceCauldronDO", 1);
			item27.RequiredItems.Add("Ooze", 5);
			item27.RequiredItems.Add("Guck", 1);
			item27.RequiredItems.Add("Entrails", 7);
			item27.CraftAmount = 2;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item27.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item28 = new Item("magic_supremacy", "FoodEitrMountainDessertDO");
			item28.Crafting.Add("EssenceCauldronDO", 1);
			item28.RequiredItems.Add("FreezeGland", 3);
			item28.RequiredItems.Add("Honey", 5);
			item28.RequiredItems.Add("Onion", 3);
			item28.CraftAmount = 2;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item28.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item29 = new Item("magic_supremacy", "FoodEitrMountainDrinkDO");
			item29.Crafting.Add("EssenceCauldronDO", 1);
			item29.RequiredItems.Add("FreezeGland", 2);
			item29.RequiredItems.Add("Crystal", 3);
			item29.RequiredItems.Add("GreydwarfEye", 3);
			item29.CraftAmount = 2;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item29.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item30 = new Item("magic_supremacy", "FoodEitrPlainsDessertDO");
			item30.Crafting.Add("EssenceCauldronDO", 1);
			item30.RequiredItems.Add("Cloudberry", 10);
			item30.RequiredItems.Add("Honey", 5);
			item30.RequiredItems.Add("BarleyFlour", 3);
			item30.CraftAmount = 2;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item30.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item31 = new Item("magic_supremacy", "FoodEitrPlainsDrinkDO");
			item31.Crafting.Add("EssenceCauldronDO", 1);
			item31.RequiredItems.Add("Cloudberry", 12);
			item31.RequiredItems.Add("Tar", 3);
			item31.RequiredItems.Add("Flax", 8);
			item31.CraftAmount = 2;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item31.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item32 = new Item("magic_supremacy", "PotionEitrBlackForestDO");
			item32.Crafting.Add("EssenceCauldronDO", 1);
			item32.RequiredItems.Add("SpiritMushroomDO", 3);
			item32.RequiredItems.Add("Honey", 10);
			item32.RequiredItems.Add("MushroomYellow", 10);
			item32.RequiredItems.Add("GreydwarfEye", 3);
			item32.CraftAmount = 6;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item32.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item33 = new Item("magic_supremacy", "PotionEitrSwampDO");
			item33.Crafting.Add("EssenceCauldronDO", 1);
			item33.RequiredItems.Add("SpiritDeathDO", 3);
			item33.RequiredItems.Add("Honey", 10);
			item33.RequiredItems.Add("Guck", 5);
			item33.RequiredItems.Add("Thistle", 5);
			item33.CraftAmount = 6;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item33.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item34 = new Item("magic_supremacy", "PotionEitrMountainDO");
			item34.Crafting.Add("EssenceCauldronDO", 1);
			item34.RequiredItems.Add("SpiritFrostDO", 3);
			item34.RequiredItems.Add("Honey", 10);
			item34.RequiredItems.Add("Crystal", 5);
			item34.RequiredItems.Add("WolfFang", 1);
			item34.CraftAmount = 6;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item34.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item35 = new Item("magic_supremacy", "PotionEitrPlainsDO");
			item35.Crafting.Add("EssenceCauldronDO", 1);
			item35.RequiredItems.Add("SpiritFireDO", 3);
			item35.RequiredItems.Add("Honey", 10);
			item35.RequiredItems.Add("Tar", 5);
			item35.RequiredItems.Add("Needle", 2);
			item35.CraftAmount = 6;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item35.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item36 = new Item("magic_supremacy", "ArmorTotemcallerChestDO");
			item36.Crafting.Add("MagicWeaverDO", 1);
			item36.RequiredItems.Add("RoundLog", 6);
			item36.RequiredItems.Add("SpiritTotemDO", 6);
			item36.RequiredItems.Add("DimEitrDO", 4);
			item36.RequiredItems.Add("LeatherScraps", 4);
			item36.RequiredUpgradeItems.Add("SpiritTotemDO", 3);
			item36.RequiredUpgradeItems.Add("DimEitrDO", 2);
			item36.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item36.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item37 = new Item("magic_supremacy", "ArmorTotemcallerLegsDO");
			item37.Crafting.Add("MagicWeaverDO", 1);
			item37.RequiredItems.Add("RoundLog", 6);
			item37.RequiredItems.Add("SpiritTotemDO", 6);
			item37.RequiredItems.Add("DimEitrDO", 4);
			item37.RequiredItems.Add("LeatherScraps", 4);
			item37.RequiredUpgradeItems.Add("SpiritTotemDO", 3);
			item37.RequiredUpgradeItems.Add("DimEitrDO", 2);
			item37.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item37.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item38 = new Item("magic_supremacy", "ArmorTotemcallerHelmetDO");
			item38.Crafting.Add("MagicWeaverDO", 1);
			item38.RequiredItems.Add("RoundLog", 6);
			item38.RequiredItems.Add("SpiritTotemDO", 6);
			item38.RequiredItems.Add("DimEitrDO", 4);
			item38.RequiredItems.Add("LeatherScraps", 4);
			item38.RequiredUpgradeItems.Add("SpiritTotemDO", 3);
			item38.RequiredUpgradeItems.Add("DimEitrDO", 2);
			item38.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item38.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item39 = new Item("magic_supremacy", "ArmorTotemcallerCapeDO");
			item39.Crafting.Add("MagicWeaverDO", 1);
			item39.RequiredItems.Add("Dandelion", 20);
			item39.RequiredItems.Add("SpiritTotemDO", 7);
			item39.RequiredItems.Add("DimEitrDO", 4);
			item39.RequiredItems.Add("Thistle", 6);
			item39.RequiredUpgradeItems.Add("SpiritTotemDO", 3);
			item39.RequiredUpgradeItems.Add("DimEitrDO", 2);
			item39.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item39.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item40 = new Item("magic_supremacy", "ArmorTotemcallerBeltDO");
			item40.Crafting.Add("MagicWeaverDO", 1);
			item40.RequiredItems.Add("AncientSeed", 10);
			item40.RequiredItems.Add("SpiritTotemDO", 6);
			item40.RequiredItems.Add("DimEitrDO", 4);
			item40.RequiredItems.Add("GreydwarfEye", 10);
			item40.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item40.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item41 = new Item("magic_supremacy", "ArmorMushroomcallerChestDO");
			item41.Crafting.Add("MagicWeaverDO", 1);
			item41.RequiredItems.Add("Mushroom", 5);
			item41.RequiredItems.Add("SpiritMushroomDO", 6);
			item41.RequiredItems.Add("DimEitrDO", 4);
			item41.RequiredItems.Add("DeerHide", 6);
			item41.RequiredUpgradeItems.Add("SpiritMushroomDO", 3);
			item41.RequiredUpgradeItems.Add("DimEitrDO", 2);
			item41.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item41.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item42 = new Item("magic_supremacy", "ArmorMushroomcallerLegsDO");
			item42.Crafting.Add("MagicWeaverDO", 1);
			item42.RequiredItems.Add("Mushroom", 5);
			item42.RequiredItems.Add("SpiritMushroomDO", 6);
			item42.RequiredItems.Add("DimEitrDO", 4);
			item42.RequiredItems.Add("DeerHide", 6);
			item42.RequiredUpgradeItems.Add("SpiritMushroomDO", 3);
			item42.RequiredUpgradeItems.Add("DimEitrDO", 2);
			item42.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item42.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item43 = new Item("magic_supremacy", "ArmorMushroomcallerHelmetDO");
			item43.Crafting.Add("MagicWeaverDO", 1);
			item43.RequiredItems.Add("Mushroom", 5);
			item43.RequiredItems.Add("SpiritMushroomDO", 6);
			item43.RequiredItems.Add("DimEitrDO", 4);
			item43.RequiredItems.Add("DeerHide", 6);
			item43.RequiredUpgradeItems.Add("SpiritMushroomDO", 3);
			item43.RequiredUpgradeItems.Add("DimEitrDO", 2);
			item43.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item43.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item44 = new Item("magic_supremacy", "ArmorMushroomcallerCapeDO");
			item44.Crafting.Add("MagicWeaverDO", 1);
			item44.RequiredItems.Add("MushroomYellow", 6);
			item44.RequiredItems.Add("SpiritMushroomDO", 7);
			item44.RequiredItems.Add("DimEitrDO", 4);
			item44.RequiredUpgradeItems.Add("SpiritMushroomDO", 3);
			item44.RequiredUpgradeItems.Add("DimEitrDO", 2);
			item44.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item44.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item45 = new Item("magic_supremacy", "ArmorMushroomcallerBeltDO");
			item45.Crafting.Add("MagicWeaverDO", 1);
			item45.RequiredItems.Add("PageArcaneDO", 4);
			item45.RequiredItems.Add("SpiritMushroomDO", 6);
			item45.RequiredItems.Add("DimEitrDO", 4);
			item45.RequiredItems.Add("MushroomYellow", 4);
			item45.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item45.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item46 = new Item("magic_supremacy", "ArmorDeathcallerChestDO");
			item46.Crafting.Add("MagicWeaverDO", 1);
			item46.RequiredItems.Add("Iron", 6);
			item46.RequiredItems.Add("SpiritDeathDO", 6);
			item46.RequiredItems.Add("DimEitrDO", 4);
			item46.RequiredItems.Add("TrollHide", 6);
			item46.RequiredUpgradeItems.Add("SpiritDeathDO", 3);
			item46.RequiredUpgradeItems.Add("DimEitrDO", 2);
			item46.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item46.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item47 = new Item("magic_supremacy", "ArmorDeathcallerLegsDO");
			item47.Crafting.Add("MagicWeaverDO", 1);
			item47.RequiredItems.Add("Iron", 6);
			item47.RequiredItems.Add("SpiritDeathDO", 6);
			item47.RequiredItems.Add("DimEitrDO", 4);
			item47.RequiredItems.Add("TrollHide", 6);
			item47.RequiredUpgradeItems.Add("SpiritDeathDO", 3);
			item47.RequiredUpgradeItems.Add("DimEitrDO", 2);
			item47.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item47.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item48 = new Item("magic_supremacy", "ArmorDeathcallerHelmetDO");
			item48.Crafting.Add("MagicWeaverDO", 1);
			item48.RequiredItems.Add("Iron", 6);
			item48.RequiredItems.Add("SpiritDeathDO", 6);
			item48.RequiredItems.Add("DimEitrDO", 4);
			item48.RequiredItems.Add("TrollHide", 6);
			item48.RequiredUpgradeItems.Add("SpiritDeathDO", 3);
			item48.RequiredUpgradeItems.Add("DimEitrDO", 2);
			item48.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item48.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item49 = new Item("magic_supremacy", "ArmorDeathcallerCapeDO");
			item49.Crafting.Add("MagicWeaverDO", 1);
			item49.RequiredItems.Add("Iron", 6);
			item49.RequiredItems.Add("SpiritDeathDO", 6);
			item49.RequiredItems.Add("DimEitrDO", 4);
			item49.RequiredItems.Add("Feathers", 10);
			item49.RequiredUpgradeItems.Add("SpiritDeathDO", 3);
			item49.RequiredUpgradeItems.Add("DimEitrDO", 2);
			item49.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item49.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item50 = new Item("magic_supremacy", "ArmorDeathcallerBeltDO");
			item50.Crafting.Add("MagicWeaverDO", 1);
			item50.RequiredItems.Add("PageArcaneDO", 10);
			item50.RequiredItems.Add("SpiritDeathDO", 10);
			item50.RequiredItems.Add("DimEitrDO", 6);
			item50.RequiredItems.Add("Guck", 6);
			item50.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item50.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item51 = new Item("magic_supremacy", "ArmorFrostcallerChestDO");
			item51.Crafting.Add("MagicWeaverDO", 2);
			item51.RequiredItems.Add("Silver", 10);
			item51.RequiredItems.Add("SpiritFrostDO", 6);
			item51.RequiredItems.Add("DimEitrDO", 4);
			item51.RequiredItems.Add("WolfPelt", 4);
			item51.RequiredUpgradeItems.Add("SpiritFrostDO", 3);
			item51.RequiredUpgradeItems.Add("DimEitrDO", 2);
			item51.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item51.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item52 = new Item("magic_supremacy", "ArmorFrostcallerLegsDO");
			item52.Crafting.Add("MagicWeaverDO", 2);
			item52.RequiredItems.Add("Silver", 10);
			item52.RequiredItems.Add("SpiritFrostDO", 6);
			item52.RequiredItems.Add("DimEitrDO", 4);
			item52.RequiredItems.Add("WolfPelt", 4);
			item52.RequiredUpgradeItems.Add("SpiritFrostDO", 3);
			item52.RequiredUpgradeItems.Add("DimEitrDO", 2);
			item52.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item52.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item53 = new Item("magic_supremacy", "ArmorFrostcallerHelmetDO");
			item53.Crafting.Add("MagicWeaverDO", 2);
			item53.RequiredItems.Add("Silver", 10);
			item53.RequiredItems.Add("SpiritFrostDO", 6);
			item53.RequiredItems.Add("DimEitrDO", 4);
			item53.RequiredItems.Add("WolfPelt", 4);
			item53.RequiredUpgradeItems.Add("SpiritFrostDO", 3);
			item53.RequiredUpgradeItems.Add("DimEitrDO", 2);
			item53.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item53.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item54 = new Item("magic_supremacy", "ArmorFrostcallerCapeDO");
			item54.Crafting.Add("MagicWeaverDO", 2);
			item54.RequiredItems.Add("WolfHairBundle", 20);
			item54.RequiredItems.Add("SpiritFrostDO", 6);
			item54.RequiredItems.Add("DimEitrDO", 4);
			item54.RequiredItems.Add("WolfPelt", 6);
			item54.RequiredUpgradeItems.Add("SpiritFrostDO", 3);
			item54.RequiredUpgradeItems.Add("DimEitrDO", 2);
			item54.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item54.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item55 = new Item("magic_supremacy", "ArmorFrostcallerBeltDO");
			item55.Crafting.Add("MagicWeaverDO", 2);
			item55.RequiredItems.Add("PageArcaneDO", 10);
			item55.RequiredItems.Add("SpiritFrostDO", 10);
			item55.RequiredItems.Add("DimEitrDO", 6);
			item55.RequiredItems.Add("FreezeGland", 6);
			item55.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item55.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item56 = new Item("magic_supremacy", "ArmorFirecallerChestDO");
			item56.Crafting.Add("MagicWeaverDO", 3);
			item56.RequiredItems.Add("BlackMetal", 10);
			item56.RequiredItems.Add("SpiritFireDO", 8);
			item56.RequiredItems.Add("DimEitrDO", 6);
			item56.RequiredItems.Add("LinenThread", 20);
			item56.RequiredUpgradeItems.Add("SpiritFireDO", 4);
			item56.RequiredUpgradeItems.Add("DimEitrDO", 3);
			item56.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item56.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item57 = new Item("magic_supremacy", "ArmorFirecallerLegsDO");
			item57.Crafting.Add("MagicWeaverDO", 3);
			item57.RequiredItems.Add("BlackMetal", 10);
			item57.RequiredItems.Add("SpiritFireDO", 8);
			item57.RequiredItems.Add("DimEitrDO", 6);
			item57.RequiredItems.Add("LinenThread", 20);
			item57.RequiredUpgradeItems.Add("SpiritFireDO", 4);
			item57.RequiredUpgradeItems.Add("DimEitrDO", 3);
			item57.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item57.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item58 = new Item("magic_supremacy", "ArmorFirecallerHelmetDO");
			item58.Crafting.Add("MagicWeaverDO", 3);
			item58.RequiredItems.Add("BlackMetal", 10);
			item58.RequiredItems.Add("SpiritFireDO", 8);
			item58.RequiredItems.Add("DimEitrDO", 6);
			item58.RequiredItems.Add("LinenThread", 20);
			item58.RequiredUpgradeItems.Add("SpiritFireDO", 4);
			item58.RequiredUpgradeItems.Add("DimEitrDO", 3);
			item58.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item58.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item59 = new Item("magic_supremacy", "ArmorFirecallerCapeDO");
			item59.Crafting.Add("MagicWeaverDO", 3);
			item59.RequiredItems.Add("Tar", 30);
			item59.RequiredItems.Add("SpiritFireDO", 8);
			item59.RequiredItems.Add("DimEitrDO", 8);
			item59.RequiredItems.Add("LinenThread", 20);
			item59.RequiredUpgradeItems.Add("SpiritFireDO", 4);
			item59.RequiredUpgradeItems.Add("DimEitrDO", 4);
			item59.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item59.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item60 = new Item("magic_supremacy", "ArmorFirecallerBeltDO");
			item60.Crafting.Add("MagicWeaverDO", 3);
			item60.RequiredItems.Add("PageArcaneDO", 10);
			item60.RequiredItems.Add("SpiritFireDO", 10);
			item60.RequiredItems.Add("DimEitrDO", 6);
			item60.RequiredItems.Add("Tar", 20);
			item60.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item60.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item61 = new Item("magic_supremacy", "ArmorStonecallerChestDO");
			item61.Crafting.Add("MagicWeaverDO", 3);
			item61.RequiredItems.Add("Stone", 60);
			item61.RequiredItems.Add("SpiritStoneDO", 8);
			item61.RequiredItems.Add("DimEitrDO", 6);
			item61.RequiredItems.Add("LinenThread", 20);
			item61.RequiredUpgradeItems.Add("SpiritStoneDO", 4);
			item61.RequiredUpgradeItems.Add("DimEitrDO", 3);
			item61.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item61.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item62 = new Item("magic_supremacy", "ArmorStonecallerLegsDO");
			item62.Crafting.Add("MagicWeaverDO", 3);
			item62.RequiredItems.Add("Stone", 60);
			item62.RequiredItems.Add("SpiritStoneDO", 8);
			item62.RequiredItems.Add("DimEitrDO", 6);
			item62.RequiredItems.Add("LinenThread", 20);
			item62.RequiredUpgradeItems.Add("SpiritStoneDO", 4);
			item62.RequiredUpgradeItems.Add("DimEitrDO", 3);
			item62.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item62.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item63 = new Item("magic_supremacy", "ArmorStonecallerHelmetDO");
			item63.Crafting.Add("MagicWeaverDO", 3);
			item63.RequiredItems.Add("Stone", 60);
			item63.RequiredItems.Add("SpiritStoneDO", 8);
			item63.RequiredItems.Add("DimEitrDO", 6);
			item63.RequiredItems.Add("LinenThread", 20);
			item63.RequiredUpgradeItems.Add("SpiritStoneDO", 4);
			item63.RequiredUpgradeItems.Add("DimEitrDO", 3);
			item63.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item63.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item64 = new Item("magic_supremacy", "ArmorStonecallerCapeDO");
			item64.Crafting.Add("MagicWeaverDO", 3);
			item64.RequiredItems.Add("Stone", 150);
			item64.RequiredItems.Add("SpiritStoneDO", 8);
			item64.RequiredItems.Add("DimEitrDO", 6);
			item64.RequiredItems.Add("Obsidian", 30);
			item64.RequiredUpgradeItems.Add("SpiritStoneDO", 4);
			item64.RequiredUpgradeItems.Add("DimEitrDO", 3);
			item64.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item64.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item65 = new Item("magic_supremacy", "ArmorStonecallerBeltDO");
			item65.Crafting.Add("MagicWeaverDO", 1);
			item65.RequiredItems.Add("PageArcaneDO", 10);
			item65.RequiredItems.Add("SpiritStoneDO", 10);
			item65.RequiredItems.Add("DimEitrDO", 6);
			item65.RequiredItems.Add("Stone", 60);
			item65.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item65.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item66 = new Item("magic_supremacy", "ArmorWindcallerChestDO");
			item66.Crafting.Add("MagicWeaverDO", 4);
			item66.RequiredItems.Add("JuteBlue", 6);
			item66.RequiredItems.Add("SpiritWindDO", 8);
			item66.RequiredItems.Add("Eitr", 10);
			item66.RequiredItems.Add("ScaleHide", 3);
			item66.RequiredUpgradeItems.Add("SpiritWindDO", 4);
			item66.RequiredUpgradeItems.Add("Eitr", 5);
			item66.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item66.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item67 = new Item("magic_supremacy", "ArmorWindcallerLegsDO");
			item67.Crafting.Add("MagicWeaverDO", 4);
			item67.RequiredItems.Add("JuteBlue", 6);
			item67.RequiredItems.Add("SpiritWindDO", 8);
			item67.RequiredItems.Add("Eitr", 10);
			item67.RequiredItems.Add("ScaleHide", 3);
			item67.RequiredUpgradeItems.Add("SpiritWindDO", 4);
			item67.RequiredUpgradeItems.Add("Eitr", 5);
			item67.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item67.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item68 = new Item("magic_supremacy", "ArmorWindcallerHelmetDO");
			item68.Crafting.Add("MagicWeaverDO", 4);
			item68.RequiredItems.Add("YggdrasilWood", 20);
			item68.RequiredItems.Add("SpiritWindDO", 8);
			item68.RequiredItems.Add("Eitr", 10);
			item68.RequiredItems.Add("JuteBlue", 2);
			item68.RequiredUpgradeItems.Add("SpiritWindDO", 4);
			item68.RequiredUpgradeItems.Add("Eitr", 5);
			item68.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item68.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item69 = new Item("magic_supremacy", "ArmorWindcallerCapeDO");
			item69.Crafting.Add("MagicWeaverDO", 4);
			item69.RequiredItems.Add("JuteRed", 10);
			item69.RequiredItems.Add("SpiritWindDO", 10);
			item69.RequiredItems.Add("Eitr", 10);
			item69.RequiredItems.Add("LinenThread", 20);
			item69.RequiredUpgradeItems.Add("SpiritWindDO", 4);
			item69.RequiredUpgradeItems.Add("Eitr", 5);
			item69.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item69.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item70 = new Item("magic_supremacy", "ArmorWindcallerBeltDO");
			item70.Crafting.Add("MagicWeaverDO", 4);
			item70.RequiredItems.Add("Tankard_dvergr", 1);
			item70.RequiredItems.Add("SpiritWindDO", 10);
			item70.RequiredItems.Add("Eitr", 16);
			item70.RequiredItems.Add("Wisp", 10);
			item70.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item70.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item71 = new Item("magic_supremacy", "ArmorLightcallerChestDO");
			item71.Crafting.Add("MagicWeaverDO", 4);
			item71.RequiredItems.Add("Bronze", 12);
			item71.RequiredItems.Add("SpiritLightDO", 8);
			item71.RequiredItems.Add("Eitr", 6);
			item71.RequiredItems.Add("LinenThread", 20);
			item71.RequiredUpgradeItems.Add("SpiritLightDO", 4);
			item71.RequiredUpgradeItems.Add("Eitr", 3);
			item71.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item71.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item72 = new Item("magic_supremacy", "ArmorLightcallerLegsDO");
			item72.Crafting.Add("MagicWeaverDO", 4);
			item72.RequiredItems.Add("Bronze", 12);
			item72.RequiredItems.Add("SpiritLightDO", 8);
			item72.RequiredItems.Add("Eitr", 6);
			item72.RequiredItems.Add("LinenThread", 20);
			item72.RequiredUpgradeItems.Add("SpiritLightDO", 4);
			item72.RequiredUpgradeItems.Add("Eitr", 3);
			item72.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item72.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item73 = new Item("magic_supremacy", "ArmorLightcallerHelmetDO");
			item73.Crafting.Add("MagicWeaverDO", 4);
			item73.RequiredItems.Add("Bronze", 12);
			item73.RequiredItems.Add("SpiritLightDO", 8);
			item73.RequiredItems.Add("Eitr", 6);
			item73.RequiredItems.Add("LinenThread", 20);
			item73.RequiredUpgradeItems.Add("SpiritLightDO", 4);
			item73.RequiredUpgradeItems.Add("Eitr", 3);
			item73.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item73.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item74 = new Item("magic_supremacy", "ArmorLightcallerCapeDO");
			item74.Crafting.Add("MagicWeaverDO", 4);
			item74.RequiredItems.Add("BlackCore", 2);
			item74.RequiredItems.Add("SpiritLightDO", 8);
			item74.RequiredItems.Add("Eitr", 6);
			item74.RequiredItems.Add("LinenThread", 20);
			item74.RequiredUpgradeItems.Add("SpiritLightDO", 4);
			item74.RequiredUpgradeItems.Add("Eitr", 3);
			item74.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item74.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item75 = new Item("magic_supremacy", "ArmorLightcallerBeltDO");
			item75.Crafting.Add("MagicWeaverDO", 4);
			item75.RequiredItems.Add("PageArcaneDO", 10);
			item75.RequiredItems.Add("SpiritLightDO", 10);
			item75.RequiredItems.Add("Eitr", 6);
			item75.RequiredItems.Add("Wisp", 8);
			item75.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item75.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item76 = new Item("magic_supremacy", "ArmorStormcallerChestDO");
			item76.Crafting.Add("MagicWeaverDO", 4);
			item76.RequiredItems.Add("FlametalNew", 10);
			item76.RequiredItems.Add("SpiritStormDO", 10);
			item76.RequiredItems.Add("Eitr", 16);
			item76.RequiredItems.Add("AskHide", 10);
			item76.RequiredUpgradeItems.Add("SpiritStormDO", 5);
			item76.RequiredUpgradeItems.Add("Eitr", 5);
			item76.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item76.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item77 = new Item("magic_supremacy", "ArmorStormcallerLegsDO");
			item77.Crafting.Add("MagicWeaverDO", 4);
			item77.RequiredItems.Add("FlametalNew", 10);
			item77.RequiredItems.Add("SpiritStormDO", 10);
			item77.RequiredItems.Add("Eitr", 16);
			item77.RequiredItems.Add("AskHide", 10);
			item77.RequiredUpgradeItems.Add("SpiritStormDO", 5);
			item77.RequiredUpgradeItems.Add("Eitr", 5);
			item77.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item77.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item78 = new Item("magic_supremacy", "ArmorStormcallerHelmetDO");
			item78.Crafting.Add("MagicWeaverDO", 4);
			item78.RequiredItems.Add("FlametalNew", 10);
			item78.RequiredItems.Add("SpiritStormDO", 10);
			item78.RequiredItems.Add("Eitr", 16);
			item78.RequiredItems.Add("AskHide", 10);
			item78.RequiredUpgradeItems.Add("SpiritStormDO", 5);
			item78.RequiredUpgradeItems.Add("Eitr", 5);
			item78.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item78.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item79 = new Item("magic_supremacy", "ArmorStormcallerCapeDO");
			item79.Crafting.Add("MagicWeaverDO", 4);
			item79.RequiredItems.Add("MorgenSinew", 4);
			item79.RequiredItems.Add("SpiritStormDO", 10);
			item79.RequiredItems.Add("Eitr", 16);
			item79.RequiredItems.Add("AskHide", 10);
			item79.RequiredUpgradeItems.Add("SpiritStormDO", 5);
			item79.RequiredUpgradeItems.Add("Eitr", 5);
			item79.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item79.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item80 = new Item("magic_supremacy", "ArmorStormcallerBeltDO");
			item80.Crafting.Add("MagicWeaverDO", 4);
			item80.RequiredItems.Add("PageArcaneDO", 10);
			item80.RequiredItems.Add("SpiritStormDO", 10);
			item80.RequiredItems.Add("Eitr", 6);
			item80.RequiredItems.Add("GemstoneBlue", 1);
			item80.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item80.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item81 = new Item("magic_supremacy", "ArmorBloodcallerChestDO");
			item81.Crafting.Add("MagicWeaverDO", 4);
			item81.RequiredItems.Add("GiantBloodSack", 4);
			item81.RequiredItems.Add("SpiritBloodDO", 10);
			item81.RequiredItems.Add("Eitr", 16);
			item81.RequiredItems.Add("AskHide", 10);
			item81.RequiredUpgradeItems.Add("SpiritBloodDO", 5);
			item81.RequiredUpgradeItems.Add("Eitr", 5);
			item81.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item81.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item82 = new Item("magic_supremacy", "ArmorBloodcallerLegsDO");
			item82.Crafting.Add("MagicWeaverDO", 4);
			item82.RequiredItems.Add("GiantBloodSack", 4);
			item82.RequiredItems.Add("SpiritBloodDO", 10);
			item82.RequiredItems.Add("Eitr", 16);
			item82.RequiredItems.Add("AskHide", 10);
			item82.RequiredUpgradeItems.Add("SpiritBloodDO", 5);
			item82.RequiredUpgradeItems.Add("Eitr", 5);
			item82.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item82.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item83 = new Item("magic_supremacy", "ArmorBloodcallerHelmetDO");
			item83.Crafting.Add("MagicWeaverDO", 4);
			item83.RequiredItems.Add("GiantBloodSack", 4);
			item83.RequiredItems.Add("SpiritBloodDO", 10);
			item83.RequiredItems.Add("Eitr", 16);
			item83.RequiredItems.Add("AskHide", 10);
			item83.RequiredUpgradeItems.Add("SpiritBloodDO", 5);
			item83.RequiredUpgradeItems.Add("Eitr", 5);
			item83.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item83.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item84 = new Item("magic_supremacy", "ArmorBloodcallerCapeDO");
			item84.Crafting.Add("MagicWeaverDO", 4);
			item84.RequiredItems.Add("JuteRed", 12);
			item84.RequiredItems.Add("SpiritBloodDO", 12);
			item84.RequiredItems.Add("Eitr", 16);
			item84.RequiredItems.Add("FlametalNew", 12);
			item84.RequiredUpgradeItems.Add("SpiritBloodDO", 5);
			item84.RequiredUpgradeItems.Add("Eitr", 5);
			item84.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item84.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item85 = new Item("magic_supremacy", "ArmorBloodcallerTrinketDO");
			item85.Crafting.Add("MagicWeaverDO", 4);
			item85.RequiredItems.Add("GemstoneRed", 1);
			item85.RequiredItems.Add("BlackCore", 1);
			item85.RequiredItems.Add("SpiritBloodDO", 10);
			item85.RequiredItems.Add("Eitr", 12);
			item85.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item85.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item86 = new Item("magic_supremacy", "StaffTotemcallerTotemDO");
			item86.Crafting.Add("MagicWeaverDO", 1);
			item86.RequiredItems.Add("TrophyFrostTroll", 1);
			item86.RequiredItems.Add("SpiritTotemDO", 8);
			item86.RequiredItems.Add("DimEitrDO", 4);
			item86.RequiredItems.Add("RoundLog", 8);
			item86.RequiredUpgradeItems.Add("SpiritTotemDO", 4);
			item86.RequiredUpgradeItems.Add("DimEitrDO", 2);
			item86.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item86.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item87 = new Item("magic_supremacy", "StaffTotemcallerBoomerangDO");
			item87.Crafting.Add("MagicWeaverDO", 1);
			item87.RequiredItems.Add("AncientSeed", 8);
			item87.RequiredItems.Add("SpiritTotemDO", 8);
			item87.RequiredItems.Add("DimEitrDO", 4);
			item87.RequiredItems.Add("RoundLog", 6);
			item87.RequiredUpgradeItems.Add("SpiritTotemDO", 4);
			item87.RequiredUpgradeItems.Add("DimEitrDO", 2);
			item87.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item87.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item88 = new Item("magic_supremacy", "StaffMushroomcallerMushroomDO");
			item88.Crafting.Add("MagicWeaverDO", 1);
			item88.RequiredItems.Add("MushroomYellow", 18);
			item88.RequiredItems.Add("SpiritMushroomDO", 8);
			item88.RequiredItems.Add("DimEitrDO", 4);
			item88.RequiredItems.Add("RoundLog", 8);
			item88.RequiredUpgradeItems.Add("SpiritMushroomDO", 4);
			item88.RequiredUpgradeItems.Add("DimEitrDO", 2);
			item88.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item88.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item89 = new Item("magic_supremacy", "StaffDeathcallerBlasterDO");
			item89.Crafting.Add("MagicWeaverDO", 1);
			item89.RequiredItems.Add("TrophyDraugrElite", 1);
			item89.RequiredItems.Add("SpiritDeathDO", 10);
			item89.RequiredItems.Add("DimEitrDO", 6);
			item89.RequiredItems.Add("Iron", 16);
			item89.RequiredUpgradeItems.Add("SpiritDeathDO", 5);
			item89.RequiredUpgradeItems.Add("DimEitrDO", 3);
			item89.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item89.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item90 = new Item("magic_supremacy", "BowFrostcallerIceDO");
			item90.Crafting.Add("MagicWeaverDO", 2);
			item90.RequiredItems.Add("FreezeGland", 20);
			item90.RequiredItems.Add("SpiritFrostDO", 10);
			item90.RequiredItems.Add("DimEitrDO", 6);
			item90.RequiredItems.Add("Crystal", 50);
			item90.RequiredUpgradeItems.Add("SpiritFrostDO", 5);
			item90.RequiredUpgradeItems.Add("DimEitrDO", 3);
			item90.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item90.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item91 = new Item("magic_supremacy", "StaffFrostcallerShotgunDO");
			item91.Crafting.Add("MagicWeaverDO", 2);
			item91.RequiredItems.Add("TrophyHatchling", 3);
			item91.RequiredItems.Add("SpiritFrostDO", 10);
			item91.RequiredItems.Add("DimEitrDO", 6);
			item91.RequiredItems.Add("Silver", 18);
			item91.RequiredUpgradeItems.Add("SpiritFrostDO", 5);
			item91.RequiredUpgradeItems.Add("DimEitrDO", 3);
			item91.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item91.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item92 = new Item("magic_supremacy", "StaffFirecallerBlasterDO");
			item92.Crafting.Add("MagicWeaverDO", 3);
			item92.RequiredItems.Add("SurtlingCore", 20);
			item92.RequiredItems.Add("SpiritFireDO", 10);
			item92.RequiredItems.Add("DimEitrDO", 8);
			item92.RequiredItems.Add("BlackMetal", 24);
			item92.RequiredUpgradeItems.Add("SpiritFireDO", 5);
			item92.RequiredUpgradeItems.Add("DimEitrDO", 4);
			item92.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item92.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item93 = new Item("magic_supremacy", "StaffFirecallerRingDO");
			item93.Crafting.Add("MagicWeaverDO", 3);
			item93.RequiredItems.Add("TrophyGoblinShaman", 1);
			item93.RequiredItems.Add("SpiritFireDO", 10);
			item93.RequiredItems.Add("DimEitrDO", 8);
			item93.RequiredItems.Add("BlackMetal", 18);
			item93.RequiredUpgradeItems.Add("SpiritFireDO", 5);
			item93.RequiredUpgradeItems.Add("DimEitrDO", 4);
			item93.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item93.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item94 = new Item("magic_supremacy", "StaffStonecallerBurstDO");
			item94.Crafting.Add("MagicWeaverDO", 3);
			item94.RequiredItems.Add("TrophyGoblinBrute", 1);
			item94.RequiredItems.Add("SpiritStoneDO", 10);
			item94.RequiredItems.Add("DimEitrDO", 8);
			item94.RequiredItems.Add("Stone", 150);
			item94.RequiredUpgradeItems.Add("SpiritStoneDO", 5);
			item94.RequiredUpgradeItems.Add("DimEitrDO", 4);
			item94.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item94.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item95 = new Item("magic_supremacy", "StaffWindcallerBuffDO");
			item95.Crafting.Add("MagicWeaverDO", 4);
			item95.RequiredItems.Add("TrophyGjall", 1);
			item95.RequiredItems.Add("SpiritWindDO", 12);
			item95.RequiredItems.Add("Eitr", 16);
			item95.RequiredItems.Add("YggdrasilWood", 20);
			item95.RequiredUpgradeItems.Add("SpiritWindDO", 5);
			item95.RequiredUpgradeItems.Add("Eitr", 8);
			item95.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item95.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item96 = new Item("magic_supremacy", "StaffLightcallerSphereDO");
			item96.Crafting.Add("MagicWeaverDO", 4);
			item96.RequiredItems.Add("MushroomJotunPuffs", 30);
			item96.RequiredItems.Add("SpiritLightDO", 12);
			item96.RequiredItems.Add("Eitr", 16);
			item96.RequiredItems.Add("Bronze", 24);
			item96.RequiredUpgradeItems.Add("SpiritLightDO", 5);
			item96.RequiredUpgradeItems.Add("Eitr", 8);
			item96.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item96.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item97 = new Item("magic_supremacy", "StaffLightcallerHealDO");
			item97.Crafting.Add("MagicWeaverDO", 4);
			item97.RequiredItems.Add("TrophySeeker", 1);
			item97.RequiredItems.Add("SpiritLightDO", 12);
			item97.RequiredItems.Add("Eitr", 16);
			item97.RequiredItems.Add("Bronze", 24);
			item97.RequiredUpgradeItems.Add("SpiritLightDO", 5);
			item97.RequiredUpgradeItems.Add("Eitr", 8);
			item97.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item97.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item98 = new Item("magic_supremacy", "StaffStormcallerSphereDO");
			item98.Crafting.Add("MagicWeaverDO", 4);
			item98.RequiredItems.Add("GemstoneBlue", 1);
			item98.RequiredItems.Add("SpiritStormDO", 14);
			item98.RequiredItems.Add("Eitr", 16);
			item98.RequiredItems.Add("FlametalNew", 10);
			item98.RequiredUpgradeItems.Add("SpiritStormDO", 6);
			item98.RequiredUpgradeItems.Add("Eitr", 8);
			item98.RequiredUpgradeItems.Add("GemstoneBlue", 1);
			item98.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item98.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item99 = new Item("magic_supremacy", "StaffStormcallerShockerDO");
			item99.Crafting.Add("MagicWeaverDO", 4);
			item99.RequiredItems.Add("GemstoneBlue", 1);
			item99.RequiredItems.Add("SpiritStormDO", 14);
			item99.RequiredItems.Add("Eitr", 16);
			item99.RequiredItems.Add("FlametalNew", 10);
			item99.RequiredUpgradeItems.Add("SpiritStormDO", 6);
			item99.RequiredUpgradeItems.Add("Eitr", 8);
			item99.RequiredUpgradeItems.Add("GemstoneBlue", 1);
			item99.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item99.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item100 = new Item("magic_supremacy", "StaffBloodcallerShotgunDO");
			item100.Crafting.Add("MagicWeaverDO", 4);
			item100.RequiredItems.Add("GemstoneRed", 1);
			item100.RequiredItems.Add("SpiritBloodDO", 14);
			item100.RequiredItems.Add("MorgenHeart", 3);
			item100.RequiredItems.Add("FlametalNew", 10);
			item100.RequiredUpgradeItems.Add("SpiritBloodDO", 6);
			item100.RequiredUpgradeItems.Add("MorgenHeart", 1);
			item100.RequiredUpgradeItems.Add("GemstoneRed", 1);
			item100.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item100.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item101 = new Item("magic_supremacy", "StaffBloodcallerHealDO");
			item101.Crafting.Add("MagicWeaverDO", 4);
			item101.RequiredItems.Add("GemstoneRed", 1);
			item101.RequiredItems.Add("SpiritBloodDO", 14);
			item101.RequiredItems.Add("GiantBloodSack", 6);
			item101.RequiredItems.Add("FlametalNew", 10);
			item101.RequiredUpgradeItems.Add("SpiritBloodDO", 6);
			item101.RequiredUpgradeItems.Add("GiantBloodSack", 2);
			item101.RequiredUpgradeItems.Add("GemstoneRed", 1);
			item101.CraftAmount = 1;
			MaterialReplacer.RegisterGameObjectForShaderSwap(item101.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			if (AzuExtendedPlayerInventory.API.IsLoaded())
			{
				bool flag = AzuExtendedPlayerInventory.API.AddSlot("$belt_DO", GetEquippedBeltSlotItem, IsBeltItem);
				Magic_SupremacyLogger.LogInfo((object)$"[Belt] AzuExtendedPlayerInventory detected. Belt slot added: {flag}");
			}
			else
			{
				Magic_SupremacyLogger.LogInfo((object)"[Belt] AzuExtendedPlayerInventory not detected. Falling back to Utility slot.");
			}
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			_harmony.PatchAll(executingAssembly);
			SetupWatcher();
		}

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

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

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

		[return: <5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)]
		private static ItemData GetEquippedBeltSlotItem(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return null;
			}
			return ((IEnumerable<ItemData>)((Humanoid)player).GetInventory().GetEquippedItems()).FirstOrDefault((Func<ItemData, bool>)IsBeltItem);
		}

		private void ApplyAllConfigValuesAfterReset()
		{
			Magic_SupremacyLogger.LogInfo((object)"[ConfigVersionManager] Config reset applied.");
		}

		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(2)]
		private static bool IsBeltItem(ItemData item)
		{
			if (item == null || (Object)(object)item.m_dropPrefab == (Object)null)
			{
				return false;
			}
			switch (((Object)item.m_dropPrefab).name)
			{
			case "ArmorDeathcallerBeltDO":
			case "ArmorFrostcallerBeltDO":
			case "ArmorStonecallerBeltDO":
			case "ArmorLightcallerBeltDO":
			case "ArmorStormcallerBeltDO":
			case "ArmorMushroomcallerBeltDO":
			case "ArmorFirecallerBeltDO":
				return true;
			default:
				return false;
			}
		}

		private ConfigEntry<T> config<[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)] T>(string group, string name, T value, ConfigDescription description, bool synchronizedSetting = true)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			ConfigDescription val = new ConfigDescription(description.Description + (synchronizedSetting ? " [Synced with Server]" : " [Not Synced with Server]"), description.AcceptableValues, description.Tags);
			ConfigEntry<T> val2 = ((BaseUnityPlugin)this).Config.Bind<T>(group, name, value, val);
			ConfigSync.AddConfigEntry<T>(val2).SynchronizedConfig = synchronizedSetting;
			return val2;
		}

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

		static Magic_SupremacyPlugin()
		{
			string configPath = Paths.ConfigPath;
			char directorySeparatorChar = Path.DirectorySeparatorChar;
			ConfigFileFullPath = configPath + directorySeparatorChar + ConfigFileName;
			ConnectionError = "";
			PinSprites = new Dictionary<string, Sprite>();
			EnableGeneratedConfigs = false;
			Magic_SupremacyLogger = Logger.CreateLogSource("Magic_Supremacy");
			ConfigSync = new ConfigSync("Dreanegade.Magic_Supremacy")
			{
				DisplayName = "Magic_Supremacy",
				CurrentVersion = "3.0.6",
				MinimumRequiredVersion = "3.0.6"
			};
			_serverConfigLocked = null;
			_recipeIsActiveConfig = null;
		}
	}
	public static class KeyboardExtensions
	{
		public static bool IsKeyDown(this KeyboardShortcut shortcut)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if ((int)((KeyboardShortcut)(ref shortcut)).MainKey != 0 && Input.GetKeyDown(((KeyboardShortcut)(ref shortcut)).MainKey))
			{
				return ((KeyboardShortcut)(ref shortcut)).Modifiers.All((Func<KeyCode, bool>)Input.GetKey);
			}
			return false;
		}

		public static bool IsKeyHeld(this KeyboardShortcut shortcut)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if ((int)((KeyboardShortcut)(ref shortcut)).MainKey != 0 && Input.GetKey(((KeyboardShortcut)(ref shortcut)).MainKey))
			{
				return ((KeyboardShortcut)(ref shortcut)).Modifiers.All((Func<KeyCode, bool>)Input.GetKey);
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
	public static class RegisterAndCheckVersion
	{
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
		private static void Prefix(ZNetPeer peer, ref ZNet __instance)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			Magic_SupremacyPlugin.Magic_SupremacyLogger.LogDebug((object)"Registering version RPC handler");
			peer.m_rpc.Register<ZPackage>("Magic_Supremacy_VersionCheck", (Action<ZRpc, ZPackage>)RpcHandlers.RPC_Magic_Supremacy_Version);
			Magic_SupremacyPlugin.Magic_SupremacyLogger.LogInfo((object)"Invoking version check");
			ZPackage val = new ZPackage();
			val.Write("3.0.6");
			peer.m_rpc.Invoke("Magic_Supremacy_VersionCheck", new object[1] { val });
		}
	}
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	[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;
			}
			Magic_SupremacyPlugin.Magic_SupremacyLogger.LogWarning((object)("Peer (" + rpc.m_socket.GetHostName() + ") never sent version or couldn't due to previous disconnect, disconnecting"));
			rpc.Invoke("Error", new object[1] { 3 });
			return false;
		}

		private static void Postfix(ZNet __instance)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "Magic_SupremacyRequestAdminSync", new object[1] { (object)new ZPackage() });
		}
	}
	[HarmonyPatch(typeof(FejdStartup), "ShowConnectError")]
	public class ShowConnectionError
	{
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>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" + Magic_SupremacyPlugin.ConnectionError;
			}
		}
	}
	[HarmonyPatch(typeof(ZNet), "Disconnect")]
	public static class RemoveDisconnectedPeerFromVerified
	{
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
		private static void Prefix(ZNetPeer peer, ref ZNet __instance)
		{
			if (__instance.IsServer())
			{
				Magic_SupremacyPlugin.Magic_SupremacyLogger.LogInfo((object)("Peer (" + peer.m_rpc.m_socket.GetHostName() + ") disconnected, removing from validated list"));
				RpcHandlers.ValidatedPeers.Remove(peer.m_rpc);
			}
		}
	}
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	public static class RpcHandlers
	{
		public static readonly List<ZRpc> ValidatedPeers = new List<ZRpc>();

		public static void RPC_Magic_Supremacy_Version(ZRpc rpc, ZPackage pkg)
		{
			string text = pkg.ReadString();
			Magic_SupremacyPlugin.Magic_SupremacyLogger.LogInfo((object)("Version check, local: 3.0.6,  remote: " + text));
			if (text != "3.0.6")
			{
				Magic_SupremacyPlugin.ConnectionError = "Magic_Supremacy Installed: 3.0.6\n Needed: " + text;
				if (ZNet.instance.IsServer())
				{
					Magic_SupremacyPlugin.Magic_SupremacyLogger.LogWarning((object)("Peer (" + rpc.m_socket.GetHostName() + ") has incompatible version, disconnecting..."));
					rpc.Invoke("Error", new object[1] { 3 });
				}
			}
			else if (!ZNet.instance.IsServer())
			{
				Magic_SupremacyPlugin.Magic_SupremacyLogger.LogInfo((object)"Received same version from server!");
			}
			else
			{
				Magic_SupremacyPlugin.Magic_SupremacyLogger.LogInfo((object)("Adding peer (" + rpc.m_socket.GetHostName() + ") to validated list"));
				ValidatedPeers.Add(rpc);
			}
		}

		public static string ComputeHashForMod()
		{
			using SHA256 sHA = SHA256.Create();
			byte[] array = sHA.ComputeHash(File.ReadAllBytes(Assembly.GetExecutingAssembly().Location));
			StringBuilder stringBuilder = new StringBuilder();
			byte[] array2 = array;
			foreach (byte b in array2)
			{
				stringBuilder.Append(b.ToString("X2"));
			}
			return stringBuilder.ToString();
		}
	}
}
namespace Magic_Supremacy.Patches
{
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[HarmonyPatch(typeof(SEMan), "AddStatusEffect", new Type[]
	{
		typeof(StatusEffect),
		typeof(bool),
		typeof(int),
		typeof(float)
	})]
	public static class SeCount
	{
		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
		private sealed class SeGroupConfig
		{
			public string GroupName;

			public int MaxCount;

			public bool IsMainGroup;

			public string[] EffectNames;

			public HashSet<int> EffectHashes;

			public SeGroupConfig(string groupName, int maxCount, bool isMainGroup, params string[] effectNames)
			{
				GroupName = groupName;
				MaxCount = maxCount;
				IsMainGroup = isMainGroup;
				EffectNames = effectNames ?? Array.Empty<string>();
				EffectHashes = new HashSet<int>();
			}
		}

		private const bool DebugLogs = false;

		private static readonly SeGroupConfig[] Groups = new SeGroupConfig[2]
		{
			new SeGroupConfig("MagicSupremacy_MainBuffs", 2, true, "SE_TotemcallerOrbit_DO", "SE_FirecallerOrbit_DO", "SE_WindcallerShield_DO", "SE_WindcallerPetal_DO", "SE_StormcallerOrbit_DO", "SE_BloodBuff_DO", "Staff_shield"),
			new SeGroupConfig("MagicSupremacy_Shields", 1, false, "SE_WindcallerShield_DO", "Staff_shield")
		};

		private static bool _initialized = false;

		private static SeGroupConfig _mainGroup = null;

		private static readonly List<SeGroupConfig> _specialGroups = new List<SeGroupConfig>();

		private static void Prefix(SEMan __instance, StatusEffect statusEffect, bool resetTime, int itemLevel, float skillLevel)
		{
			try
			{
				EnsureInitialized();
				if (__instance == null)
				{
					Log("Prefix skipped: __instance is null.");
					return;
				}
				if ((Object)(object)statusEffect == (Object)null)
				{
					Log("Prefix skipped: incoming statusEffect is null.");
					return;
				}
				int num = statusEffect.NameHash();
				if (num == 0)
				{
					Log("Prefix skipped: incoming statusEffect hash is 0.");
					return;
				}
				if ((Object)(object)__instance.GetStatusEffect(num) != (Object)null)
				{
					Log($"Incoming SE already active, skipping replacement logic: {GetSafeEffectName(statusEffect)} ({num})");
					return;
				}
				List<StatusEffect> statusEffects = __instance.GetStatusEffects();
				if (statusEffects == null)
				{
					Log("Active effects list is null.");
					return;
				}
				HashSet<int> hashSet = new HashSet<int>();
				for (int i = 0; i < _specialGroups.Count; i++)
				{
					SeGroupConfig seGroupConfig = _specialGroups[i];
					if (seGroupConfig != null && seGroupConfig.EffectHashes.Contains(num))
					{
						ProcessGroup(seGroupConfig, num, statusEffects, hashSet, includeIncoming: true);
					}
				}
				if (_mainGroup != null && _mainGroup.EffectHashes.Contains(num))
				{
					ProcessGroup(_mainGroup, num, statusEffects, hashSet, includeIncoming: true);
				}
				if (hashSet.Count == 0)
				{
					Log($"No replacements needed for incoming SE: {GetSafeEffectName(statusEffect)} ({num})");
					return;
				}
				foreach (int item in hashSet)
				{
					StatusEffect statusEffect2 = __instance.GetStatusEffect(item);
					if ((Object)(object)statusEffect2 == (Object)null)
					{
						Log($"Removal skipped: SE hash not found anymore: {item}");
					}
					else if (__instance.RemoveStatusEffect(item, true))
					{
						Log($"Removed old SE due to group limit: {GetSafeEffectName(statusEffect2)} ({item})");
					}
					else
					{
						Log($"Failed to remove old SE: {GetSafeEffectName(statusEffect2)} ({item})");
					}
				}
			}
			catch (Exception arg)
			{
				Debug.LogError((object)$"[SeCount] Exception in Prefix: {arg}");
			}
		}

		private static void ProcessGroup(SeGroupConfig group, int incomingHash, List<StatusEffect> activeEffects, HashSet<int> hashesToRemove, bool includeIncoming)
		{
			if (group == null)
			{
				return;
			}
			if (group.MaxCount <= 0)
			{
				Log($"Group '{group.GroupName}' skipped: invalid MaxCount={group.MaxCount}");
				return;
			}
			List<StatusEffect> list = new List<StatusEffect>();
			for (int i = 0; i < activeEffects.Count; i++)
			{
				StatusEffect val = activeEffects[i];
				if (!((Object)(object)val == (Object)null))
				{
					int num = val.NameHash();
					if (num != 0 && group.EffectHashes.Contains(num) && !hashesToRemove.Contains(num))
					{
						list.Add(val);
					}
				}
			}
			int count = list.Count;
			int num2 = count + (includeIncoming ? 1 : 0);
			Log($"Group '{group.GroupName}': active={count}, projected={num2}, max={group.MaxCount}, incomingHash={incomingHash}");
			if (num2 <= group.MaxCount)
			{
				return;
			}
			int num3 = num2 - group.MaxCount;
			Log($"Group '{group.GroupName}' exceeded. Need to remove {num3} old effect(s).");
			for (int j = 0; j < list.Count; j++)
			{
				if (num3 <= 0)
				{
					break;
				}
				StatusEffect val2 = list[j];
				if (!((Object)(object)val2 == (Object)null))
				{
					int num4 = val2.NameHash();
					if (num4 != 0 && hashesToRemove.Add(num4))
					{
						num3--;
						Log($"Marked for removal from group '{group.GroupName}': {GetSafeEffectName(val2)} ({num4})");
					}
				}
			}
		}

		private static void EnsureInitialized()
		{
			if (_initialized)
			{
				return;
			}
			_mainGroup = null;
			_specialGroups.Clear();
			for (int i = 0; i < Groups.Length; i++)
			{
				SeGroupConfig seGroupConfig = Groups[i];
				if (seGroupConfig == null)
				{
					continue;
				}
				seGroupConfig.EffectHashes.Clear();
				if (string.IsNullOrWhiteSpace(seGroupConfig.GroupName))
				{
					seGroupConfig.GroupName = $"Group_{i}";
				}
				if (seGroupConfig.EffectNames != null)
				{
					for (int j = 0; j < seGroupConfig.EffectNames.Length; j++)
					{
						string text = seGroupConfig.EffectNames[j];
						if (!string.IsNullOrWhiteSpace(text))
						{
							string text2 = text.Trim();
							int stableHashCode = StringExtensionMethods.GetStableHashCode(text2);
							if (!seGroupConfig.EffectHashes.Add(stableHashCode))
							{
								Log("Duplicate effect '" + text2 + "' in group '" + seGroupConfig.GroupName + "'");
							}
						}
					}
				}
				if (seGroupConfig.IsMainGroup)
				{
					if (_mainGroup != null)
					{
						Debug.LogWarning((object)("[SeCount] Multiple main groups detected. Last one wins: '" + seGroupConfig.GroupName + "'"));
					}
					_mainGroup = seGroupConfig;
				}
				else
				{
					_specialGroups.Add(seGroupConfig);
				}
				Log($"Initialized group '{seGroupConfig.GroupName}' | Main={seGroupConfig.IsMainGroup} | MaxCount={seGroupConfig.MaxCount} | Entries={seGroupConfig.EffectHashes.Count}");
			}
			if (_mainGroup == null)
			{
				Debug.LogWarning((object)"[SeCount] No main group configured.");
			}
			_initialized = true;
		}

		private static string GetSafeEffectName(StatusEffect se)
		{
			if ((Object)(object)se == (Object)null)
			{
				return "<null>";
			}
			if (!string.IsNullOrEmpty(((Object)se).name))
			{
				return ((Object)se).name;
			}
			return ((object)se).GetType().Name;
		}

		private static void Log(string message)
		{
		}
	}
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[HarmonyPatch(typeof(Aoe), "Setup")]
	public static class AoeCount
	{
		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
		private sealed class LimitedAoeConfig
		{
			public string PrefabName;

			public int MaxCount;

			public LimitedAoeConfig(string prefabName, int maxCount)
			{
				PrefabName = prefabName;
				MaxCount = maxCount;
			}
		}

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
		private sealed class TrackedAoeEntry
		{
			public GameObject GameObject;

			public int InstanceId;

			public long Sequence;

			public string PrefabName;

			public long PlayerId;
		}

		private const bool DebugLogs = false;

		private static readonly LimitedAoeConfig[] LimitedAoes = new LimitedAoeConfig[9]
		{
			new LimitedAoeConfig("aoe_mushroomcaller_set_DO", 6),
			new LimitedAoeConfig("aoe_mushroomcaller_staff_trap_DO", 6),
			new LimitedAoeConfig("aoe_mushroomcaller_staff_light_DO", 4),
			new LimitedAoeConfig("aoe_totemcaller_staff_pull_DO", 2),
			new LimitedAoeConfig("aoe_totemcaller_staff_buff_DO", 2),
			new LimitedAoeConfig("aoe_frostcaller_staff_bow_trap_DO", 3),
			new LimitedAoeConfig("aoe_lightcaller_staff_sigil_DO", 3),
			new LimitedAoeConfig("aoe_lightcaller_staff_light_DO", 3),
			new LimitedAoeConfig("aoe_stormcaller_staff_sphere_trap_DO", 6)
		};

		private static readonly Dictionary<string, int> LimitedAoeMap = BuildConfigMap();

		private static readonly Dictionary<long, Dictionary<string, List<TrackedAoeEntry>>> ActiveAoesByPlayer = new Dictionary<long, Dictionary<string, List<TrackedAoeEntry>>>();

		private static readonly HashSet<int> RegisteredInstanceIds = new HashSet<int>();

		private static long _spawnSequence = 0L;

		private static void Postfix(Aoe __instance, Character owner)
		{
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)__instance == (Object)null)
				{
					Log("Setup postfix skipped: __instance is null.");
					return;
				}
				GameObject gameObject = ((Component)__instance).gameObject;
				if ((Object)(object)gameObject == (Object)null)
				{
					Log("Setup postfix skipped: aoeObject is null.");
					return;
				}
				string text = NormalizeName(((Object)gameObject).name);
				if (!LimitedAoeMap.TryGetValue(text, out var value))
				{
					return;
				}
				if (value <= 0)
				{
					Log($"Prefab '{text}' is configured with invalid maxCount={value}. Skipping.");
					return;
				}
				Player val = (Player)(object)((owner is Player) ? owner : null);
				if (val == null)
				{
					Log("Prefab '" + text + "' skipped: owner is not Player.");
					return;
				}
				long playerID = val.GetPlayerID();
				if (playerID == 0L)
				{
					Log("Prefab '" + text + "' skipped: playerId is 0.");
					return;
				}
				int instanceID = ((Object)gameObject).GetInstanceID();
				if (RegisteredInstanceIds.Contains(instanceID))
				{
					Log($"Duplicate Setup registration skipped for '{text}', instanceId={instanceID}, playerId={playerID}");
					return;
				}
				if (!ActiveAoesByPlayer.TryGetValue(playerID, out var value2))
				{
					value2 = new Dictionary<string, List<TrackedAoeEntry>>();
					ActiveAoesByPlayer[playerID] = value2;
				}
				if (!value2.TryGetValue(text, out var value3))
				{
					value3 = (value2[text] = new List<TrackedAoeEntry>());
				}
				CleanupDeadEntries(value3);
				TrackedAoeEntry item = new TrackedAoeEntry
				{
					GameObject = gameObject,
					InstanceId = instanceID,
					Sequence = ++_spawnSequence,
					PrefabName = text,
					PlayerId = playerID
				};
				value3.Add(item);
				RegisteredInstanceIds.Add(instanceID);
				Log($"Registered AOE '{text}' for playerId={playerID}. Count={value3.Count}/{value}. Pos={gameObject.transform.position}");
				EnforceLimit(value3, value, text, playerID);
			}
			catch (Exception arg)
			{
				Debug.LogError((object)$"[AoeCount] Exception in Setup postfix: {arg}");
			}
		}

		private static void EnforceLimit(List<TrackedAoeEntry> entries, int maxCount, string prefabName, long playerId)
		{
			CleanupDeadEntries(entries);
			while (entries.Count > maxCount)
			{
				TrackedAoeEntry trackedAoeEntry = FindOldest(entries);
				if (trackedAoeEntry == null)
				{
					Log($"EnforceLimit: oldest entry is null for prefab='{prefabName}', playerId={playerId}");
					break;
				}
				Log($"Limit exceeded for prefab='{prefabName}', playerId={playerId}. Count={entries.Count}, limit={maxCount}. Removing oldest instanceId={trackedAoeEntry.InstanceId}, sequence={trackedAoeEntry.Sequence}");
				DestroyTrackedEntry(trackedAoeEntry);
				entries.Remove(trackedAoeEntry);
			}
			CleanupDeadEntries(entries);
			Log($"Post-limit state for prefab='{prefabName}', playerId={playerId}: Count={entries.Count}/{maxCount}");
		}

		private static TrackedAoeEntry FindOldest(List<TrackedAoeEntry> entries)
		{
			TrackedAoeEntry trackedAoeEntry = null;
			for (int i = 0; i < entries.Count; i++)
			{
				TrackedAoeEntry trackedAoeEntry2 = entries[i];
				if (trackedAoeEntry2 != null && (trackedAoeEntry == null || trackedAoeEntry2.Sequence < trackedAoeEntry.Sequence))
				{
					trackedAoeEntry = trackedAoeEntry2;
				}
			}
			return trackedAoeEntry;
		}

		private static void DestroyTrackedEntry(TrackedAoeEntry entry)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			if (entry == null)
			{
				return;
			}
			RegisteredInstanceIds.Remove(entry.InstanceId);
			if ((Object)(object)entry.GameObject == (Object)null)
			{
				Log($"DestroyTrackedEntry skipped: GameObject already null for instanceId={entry.InstanceId}");
				return;
			}
			string prefabName = entry.PrefabName;
			Vector3 position = entry.GameObject.transform.position;
			if ((Object)(object)ZNetScene.instance != (Object)null)
			{
				Log($"Destroying oldest AOE via ZNetScene.Destroy: prefab='{prefabName}', instanceId={entry.InstanceId}, pos={position}");
				ZNetScene.instance.Destroy(entry.GameObject);
			}
			else
			{
				Log($"ZNetScene.instance is null, fallback Object.Destroy: prefab='{prefabName}', instanceId={entry.InstanceId}, pos={position}");
				Object.Destroy((Object)(object)entry.GameObject);
			}
		}

		private static void CleanupDeadEntries(List<TrackedAoeEntry> entries)
		{
			if (entries == null || entries.Count == 0)
			{
				return;
			}
			for (int num = entries.Count - 1; num >= 0; num--)
			{
				TrackedAoeEntry trackedAoeEntry = entries[num];
				if (trackedAoeEntry == null || (Object)(object)trackedAoeEntry.GameObject == (Object)null)
				{
					if (trackedAoeEntry != null)
					{
						RegisteredInstanceIds.Remove(trackedAoeEntry.InstanceId);
					}
					entries.RemoveAt(num);
				}
			}
		}

		private static Dictionary<string, int> BuildConfigMap()
		{
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.Ordinal);
			for (int i = 0; i < LimitedAoes.Length; i++)
			{
				LimitedAoeConfig limitedAoeConfig = LimitedAoes[i];
				if (limitedAoeConfig == null)
				{
					continue;
				}
				string text = NormalizeName(limitedAoeConfig.PrefabName);
				if (string.IsNullOrWhiteSpace(text))
				{
					continue;
				}
				if (limitedAoeConfig.MaxCount <= 0)
				{
					Debug.LogWarning((object)("[AoeCount] Config skipped for '" + text + "': MaxCount must be > 0."));
					continue;
				}
				if (dictionary.ContainsKey(text))
				{
					Debug.LogWarning((object)("[AoeCount] Duplicate config for prefab '" + text + "'. Last value wins."));
				}
				dictionary[text] = limitedAoeConfig.MaxCount;
			}
			return dictionary;
		}

		private static string NormalizeName(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return string.Empty;
			}
			int num = name.IndexOf("(Clone)", StringComparison.Ordinal);
			if (num >= 0)
			{
				name = name.Substring(0, num);
			}
			return name.Trim();
		}

		private static void Log(string message)
		{
		}
	}
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	[HarmonyPatch(typeof(Aoe), "OnHit")]
	public static class AoeOneHit
	{
		private const bool DebugLogs = false;

		private static readonly Dictionary<string, string> OneHitAoeRegistry = new Dictionary<string, string>
		{
			{ "aoe_mushroomcaller_set_DO", "fx_mushroomcaller_staff_trap_hit_DO" },
			{ "aoe_mushroomcaller_staff_trap_DO", "fx_mushroomcaller_staff_trap_hit_DO" },
			{ "aoe_lightcaller_staff_sigil_DO", "fx_lightcaller_staff_sigil_hit_DO" },
			{ "aoe_frostcaller_staff_bow_trap_DO", "fx_frostcaller_staff_bow_trap_hit_DO" },
			{ "aoe_stormcaller_staff_sphere_trap_DO", "fx_stormcaller_staff_sphere_trap_hit_DO" }
		};

		private static readonly HashSet<int> PendingDestroyInstanceIds = new HashSet<int>();

		private static void Postfix(Aoe __instance, bool __result)
		{
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!__result)
				{
					return;
				}
				if ((Object)(object)__instance == (Object)null)
				{
					Log("Postfix skipped: __instance is null.");
					return;
				}
				GameObject gameObject = ((Component)__instance).gameObject;
				if ((Object)(object)gameObject == (Object)null)
				{
					Log("Postfix skipped: AOE gameObject is null.");
					return;
				}
				string text = NormalizeName(((Object)gameObject).name);
				if (!OneHitAoeRegistry.TryGetValue(text, out var value))
				{
					return;
				}
				int instanceID = ((Object)gameObject).GetInstanceID();
				if (PendingDestroyInstanceIds.Contains(instanceID))
				{
					Log("Destroy skipped (already pending): " + text);
					return;
				}
				PendingDestroyInstanceIds.Add(instanceID);
				Log("One-hit AOE triggered: " + text);
				if (!string.IsNullOrWhiteSpace(value))
				{
					SpawnCenterFx(value, ((Component)__instance).transform.position, ((Component)__instance).transform.rotation, text);
				}
				else
				{
					Log("No center FX configured for: " + text);
				}
				if ((Object)(object)ZNetScene.instance != (Object)null)
				{
					Log("Destroying AOE via ZNetScene.Destroy: " + text);
					ZNetScene.instance.Destroy(gameObject);
				}
				else
				{
					Log("ZNetScene.instance is null, fallback Object.Destroy: " + text);
					Object.Destroy((Object)(object)gameObject);
				}
			}
			catch (Exception arg)
			{
				Debug.LogError((object)$"[AoeOneHit] Exception in Postfix: {arg}");
			}
		}

		private static void SpawnCenterFx(string fxPrefabName, Vector3 position, Quaternion rotation, string aoePrefabName)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = FindPrefab(fxPrefabName);
			if ((Object)(object)val == (Object)null)
			{
				Log("Center FX prefab not found for AOE '" + aoePrefabName + "': " + fxPrefabName);
				return;
			}
			Object.Instantiate<GameObject>(val, position, rotation);
			Log($"Spawned center FX '{fxPrefabName}' for AOE '{aoePrefabName}' at {position}");
		}

		private static GameObject FindPrefab(string prefabName)
		{
			if (string.IsNullOrWhiteSpace(prefabName))
			{
				return null;
			}
			string text = NormalizeName(prefabName);
			if ((Object)(object)ZNetScene.instance != (Object)null)
			{
				GameObject prefab = ZNetScene.instance.GetPrefab(text);
				if ((Object)(object)prefab != (Object)null)
				{
					return prefab;
				}
			}
			if ((Object)(object)ObjectDB.instance != (Object)null)
			{
				GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(text);
				if ((Object)(object)itemPrefab != (Object)null)
				{
					return itemPrefab;
				}
			}
			return null;
		}

		private static string NormalizeName(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return string.Empty;
			}
			int num = name.IndexOf("(Clone)");
			if (num >= 0)
			{
				name = name.Substring(0, num);
			}
			return name.Trim();
		}

		private static void Log(string message)
		{
		}
	}
}
namespace CreatureManager
{
	public enum Toggle
	{
		On,
		Off
	}
	[PublicAPI]
	public enum GlobalKey
	{
		[InternalName("")]
		None,
		[InternalName("defeated_bonemass")]
		KilledBonemass,
		[InternalName("defeated_gdking")]
		KilledElder,
		[InternalName("defeated_goblinking")]
		KilledYagluth,
		[InternalName("defeated_dragon")]
		KilledModer,
		[InternalName("defeated_eikthyr")]
		KilledEikthyr,
		[InternalName("KilledTroll")]
		KilledTroll,
		[InternalName("killed_surtling")]
		KilledSurtling
	}
	[PublicAPI]
	[Flags]
	public enum Weather
	{
		[InternalName("")]
		None = 0,
		[InternalName("Clear")]
		ClearSkies = 1,
		[InternalName("Heath clear")]
		MeadowsClearSkies = 4,
		[InternalName("LightRain")]
		LightRain = 8,
		[InternalName("Rain")]
		Rain = 0x10,
		[InternalName("ThunderStorm")]
		ThunderStorm = 0x20,
		[InternalName("nofogts")]
		ClearThunderStorm = 0x40,
		[InternalName("SwampRain")]
		SwampRain = 0x80,
		[InternalName("Darklands_dark")]
		MistlandsDark = 0x100,
		[InternalName("Ashrain")]
		AshlandsAshrain = 0x200,
		[InternalName("Snow")]
		MountainSnow = 0x400,
		[InternalName("SnowStorm")]
		MountainBlizzard = 0x800,
		[InternalName("DeepForest Mist")]
		BlackForestFog = 0x1000,
		[InternalName("Misty")]
		Fog = 0x2000,
		[InternalName("Twilight_Snow")]
		DeepNorthSnow = 0x4000,
		[InternalName("Twilight_SnowStorm")]
		DeepNorthSnowStorm = 0x8000,
		[InternalName("Twilight_Clear")]
		DeepNorthClear = 0x10000,
		[InternalName("Eikthyr")]
		EikthyrsThunderstorm = 0x20000,
		[InternalName("GDKing")]
		EldersHaze = 0x40000,
		[InternalName("Bonemass")]
		BonemassDownpour = 0x80000,
		[InternalName("Moder")]
		ModersVortex = 0x100000,
		[InternalName("GoblinKing")]
		YagluthsMagicBlizzard = 0x200000,
		[InternalName("Crypt")]
		Crypt = 0x400000,
		[InternalName("SunkenCrypt")]
		SunkenCrypt = 0x800000
	}
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	public class InternalName : Attribute
	{
		public readonly string internalName;

		public InternalName(string internalName)
		{
			this.internalName = internalName;
		}
	}
	public enum DropOption
	{
		Disabled,
		Default,
		Custom
	}
	public enum SpawnOption
	{
		Disabled,
		Default,
		Custom
	}
	public enum SpawnTime
	{
		Day,
		Night,
		Always
	}
	public enum SpawnArea
	{
		Center,
		Edge,
		Everywhere
	}
	public enum Forest
	{
		Yes,
		No,
		Both
	}
	[PublicAPI]
	public struct Range
	{
		public float min;

		public float max;

		public Range(float min, float max)
		{
			this.min = min;
			this.max = max;
		}
	}
	[PublicAPI]
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	public class Creature
	{
		[PublicAPI]
		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
		public class DropList
		{
			[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
			internal class SerializedDrops
			{
				[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(new byte[] { 1, 0, 1, 1 })]
				public readonly List<KeyValuePair<string, Drop>> Drops;

				public SerializedDrops(DropList drops, Creature creature)
				{
					Drops = (drops.drops ?? creature.Prefab.GetComponent<CharacterDrop>()?.m_drops.ToDictionary([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (Drop drop) => ((Object)drop.m_prefab).name, [<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (Drop drop) => new Drop
					{
						Amount = new Range(drop.m_amountMin, drop.m_amountMax),
						DropChance = drop.m_chance,
						DropOnePerPlayer = drop.m_onePerPlayer,
						MultiplyDropByLevel = drop.m_levelMultiplier
					}) ?? new Dictionary<string, Drop>()).ToList();
				}

				public SerializedDrops([<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(new byte[] { 1, 0, 1, 1 })] List<KeyValuePair<string, Drop>> drops)
				{
					Drops = drops;
				}

				public SerializedDrops(string reqs)
				{
					Drops = (from r in reqs.Split(new char[1] { ',' })
						select r.Split(new char[1] { ':' })).ToDictionary([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (string[] l) => l[0], [<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (string[] parts) =>
					{
						Range amount = new Range(1f, 1f);
						if (parts.Length > 1)
						{
							string[] array = parts[1].Split(new char[1] { '-' });
							if (!int.TryParse(array[0], out var result))
							{
								result = 1;
							}
							if (array.Length == 1 || !int.TryParse(array[0], out var result2))
							{
								result2 = result;
							}
							amount = new Range(result, result2);
						}
						float result3;
						return new Drop
						{
							Amount = amount,
							DropChance = ((parts.Length > 2 && float.TryParse(parts[2], out result3)) ? result3 : 100f),
							DropOnePerPlayer = (parts.Length > 3 && parts[3] == "onePerPlayer"),
							MultiplyDropByLevel = (parts.Length > 4 && parts[4] == "multiplyByLevel")
						};
					}).ToList();
				}

				public override string ToString()
				{
					return string.Join(",", Drops.Select([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (KeyValuePair<string, Drop> kv) => string.Format("{0}:{1}-{2}:{3}:{4}:{5}", kv.Key, kv.Value.Amount.min, kv.Value.Amount.max, kv.Value.DropChance, kv.Value.DropOnePerPlayer ? "onePerPlayer" : "unrestricted", kv.Value.MultiplyDropByLevel ? "multiplyByLevel" : "unaffectedByLevel")));
				}
			}

			[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(new byte[] { 2, 1, 1 })]
			private Dictionary<string, Drop> drops;

			public Drop this[string prefabName]
			{
				get
				{
					if (!(drops ?? (drops = new Dictionary<string, Drop>())).TryGetValue(prefabName, out var value))
					{
						return drops[prefabName] = new Drop();
					}
					return value;
				}
			}

			public void None()
			{
				drops = new Dictionary<string, Drop>();
			}

			[HarmonyPriority(700)]
			internal static void AddDropsToCreature()
			{
				foreach (Creature registeredCreature in registeredCreatures)
				{
					UpdateDrops(registeredCreature);
				}
			}

			internal static void UpdateDrops(Creature creature)
			{
				if (creatureConfigs[creature].Drops.get() == DropOption.Default && creature.Drops.drops == null)
				{
					return;
				}
				CharacterDrop val = creature.Prefab.GetComponent<CharacterDrop>() ?? creature.Prefab.AddComponent<CharacterDrop>();
				val.m_drops = (from d in (creatureConfigs[creature].Drops.get() switch
					{
						DropOption.Custom => new SerializedDrops(creatureConfigs[creature].CustomDrops.get()).Drops, 
						DropOption.Disabled => new List<KeyValuePair<string, Drop>>(), 
						_ => creature.Drops.drops.ToList(), 
					}).Select((Func<KeyValuePair<string, Drop>, Drop>)([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (KeyValuePair<string, Drop> kv) =>
					{
						//IL_005e: Unknown result type (might be due to invalid IL or missing references)
						//IL_0063: Unknown result type (might be due to invalid IL or missing references)
						//IL_006a: Unknown result type (might be due to invalid IL or missing references)
						//IL_0082: Unknown result type (might be due to invalid IL or missing references)
						//IL_009a: Unknown result type (might be due to invalid IL or missing references)
						//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
						//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
						//IL_00d7: Expected O, but got Unknown
						if (kv.Key == "" || ZNetScene.instance == null)
						{
							return null;
						}
						GameObject prefab = ZNetScene.instance.GetPrefab(kv.Key);
						if (prefab != null)
						{
							return new Drop
							{
								m_prefab = prefab,
								m_amountMin = (int)kv.Value.Amount.min,
								m_amountMax = (int)kv.Value.Amount.max,
								m_chance = kv.Value.DropChance / 100f,
								m_onePerPlayer = kv.Value.DropOnePerPlayer,
								m_levelMultiplier = kv.Value.MultiplyDropByLevel
							};
						}
						Debug.LogWarning((object)("Found invalid prefab name " + kv.Key + " for creature " + ((Object)creature.Prefab).name));
						return null;
					}))
					where d != null
					select d).ToList();
			}
		}

		[PublicAPI]
		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		public class Drop
		{
			public Range Amount = new Range(1f, 1f);

			public float DropChance = 100f;

			public bool DropOnePerPlayer;

			public bool MultiplyDropByLevel = true;
		}

		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		private class CustomConfig<[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)] T>
		{
			[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(1)]
			public Func<T> get;

			[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(new byte[] { 2, 1 })]
			public ConfigEntry<T> config;
		}

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
		private class CreatureConfig
		{
			public readonly CustomConfig<SpawnOption> Spawn = new CustomConfig<SpawnOption>();

			public readonly CustomConfig<Toggle> CanBeTamed = new CustomConfig<Toggle>();

			public readonly CustomConfig<string> ConsumesItemName = new CustomConfig<string>();

			public readonly CustomConfig<SpawnTime> SpecificSpawnTime = new CustomConfig<SpawnTime>();

			public readonly CustomConfig<Range> RequiredAltitude = new CustomConfig<Range>();

			public readonly CustomConfig<Range> RequiredOceanDepth = new CustomConfig<Range>();

			public readonly CustomConfig<GlobalKey> RequiredGlobalKey = new CustomConfig<GlobalKey>();

			public readonly CustomConfig<Range> GroupSize = new CustomConfig<Range>();

			public readonly CustomConfig<Biome> Biome = new CustomConfig<Biome>();

			public readonly CustomConfig<SpawnArea> SpecificSpawnArea = new CustomConfig<SpawnArea>();

			public readonly CustomConfig<Weather> RequiredWeather = new CustomConfig<Weather>();

			public readonly CustomConfig<float> SpawnAltitude = new CustomConfig<float>();

			public readonly CustomConfig<Toggle> CanHaveStars = new CustomConfig<Toggle>();

			public readonly CustomConfig<Toggle> AttackImmediately = new CustomConfig<Toggle>();

			public readonly CustomConfig<int> CheckSpawnInterval = new CustomConfig<int>();

			public readonly CustomConfig<float> SpawnChance = new CustomConfig<float>();

			public readonly CustomConfig<Forest> ForestSpawn = new CustomConfig<Forest>();

			public readonly CustomConfig<int> Maximum = new CustomConfig<int>();

			public readonly CustomConfig<DropOption> Drops = new CustomConfig<DropOption>();

			public readonly CustomConfig<string> CustomDrops = new CustomConfig<string>();
		}

		[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)]
		private class ConfigurationManagerAttributes
		{
			[UsedImplicitly]
			public int? Order;

			[UsedImplicitly]
			public bool? Browsable;

			[UsedImplicitly]
			[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)]
			public string Category;

			[UsedImplicitly]
			[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(new byte[] { 2, 1 })]
			public Action<ConfigEntryBase> CustomDrawer;
		}

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
		private class AcceptableEnumValues<[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)] T> : AcceptableValueBase where T : struct, IConvertible
		{
			[PublicAPI]
			[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(new byte[] { 1, 0 })]
			public virtual T[] AcceptableValues
			{
				[return: <5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(new byte[] { 1, 0 })]
				get;
			}

			public AcceptableEnumValues([<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(new byte[] { 1, 0 })] params T[] acceptableValues)
				: base(typeof(T))
			{
				AcceptableValues = acceptableValues;
			}

			public override object Clamp(object value)
			{
				if (!((AcceptableValueBase)this).IsValid(value))
				{
					return AcceptableValues[0];
				}
				return value;
			}

			public override bool IsValid(object value)
			{
				return AcceptableValues.Contains((T)value);
			}

			public override string ToDescriptionString()
			{
				return string.Join(", ", AcceptableValues);
			}
		}

		public bool ConfigurationEnabled = true;

		public readonly GameObject Prefab;

		public DropList Drops = new DropList();

		public bool CanSpawn = true;

		public bool CanBeTamed;

		[Description("List of items the creature consumes to get tame.\nFor multiple item names, separate them with a comma.")]
		public string FoodItems;

		[Description("Sets the time of day the creature can spawn.")]
		public SpawnTime SpecificSpawnTime = SpawnTime.Always;

		[Description("Sets the minimum and maximum altitude for the creature to spawn.")]
		public Range RequiredAltitude = new Range(5f, 1000f);

		[Description("Sets the minimum and maximum depth of the ocean for the creature to spawn.")]
		public Range RequiredOceanDepth = new Range(0f, 0f);

		[Description("Sets a global key required for the creature to spawn.")]
		public GlobalKey RequiredGlobalKey;

		[Description("Sets a range for the group size the creature spawns in.")]
		public Range GroupSize = new Range(1f, 1f);

		[Description("Sets the biome the creature spawns in.")]
		public Biome Biome = (Biome)1;

		[Description("Sets spawning area for the creature inside the biome.\nUse SpawnArea.Edge, to make the creature spawn more towards the edge of the biome.\nUse SpawnArea.Center, to make the creature spawn more towards the center of the biome.")]
		public SpawnArea SpecificSpawnArea = SpawnArea.Everywhere;

		[Description("Sets the weather condition for the creature to spawn.\nUse the Weather enum for easy configuration.")]
		public Weather RequiredWeather;

		[Description("Sets altitude relative to the current ground level for the creature to spawn.\nShould be a higher number for flying creatures, so they spawn in the sky.")]
		public float SpawnAltitude = 0.5f;

		public bool CanHaveStars = true;

		[Description("Controls the first AI command right after spawn.\nSet to true for the creature to immediately start to hunt down the player.")]
		public bool AttackImmediately;

		[Description("The time between attempts to spawn the creature in.")]
		public int CheckSpawnInterval = 600;

		[Description("The chance in percent for the creature to spawn, every time Valheim checks if it should spawn.")]
		public float SpawnChance = 100f;

		[Description("Can be used to make the creature spawn in forests or prevent it from spawning in forests.\nUse the Forest enum for easy configuration.")]
		public Forest ForestSpawn = Forest.Both;

		[Description("Sets the maximum number of the creature that can be near the player, before Valheim disables its spawn.")]
		public int Maximum = 1;

		private static readonly List<Creature> registeredCreatures = new List<Creature>();

		private static Dictionary<Creature, CreatureConfig> creatureConfigs = new Dictionary<Creature, CreatureConfig>();

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)]
		private static object configManager;

		private static List<SpawnData> lastRegisteredSpawns = new List<SpawnData>();

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)]
		private static Localization _english;

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)]
		private static BaseUnityPlugin _plugin;

		private static bool hasConfigSync = true;

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)]
		private static object _configSync;

		private static Localization english
		{
			get
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Expected O, but got Unknown
				if (_english == null)
				{
					_english = new Localization();
					_english.SetupLanguage("English");
				}
				return _english;
			}
		}

		private static BaseUnityPlugin plugin
		{
			get
			{
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: Expected O, but got Unknown
				if (_plugin == null)
				{
					IEnumerable<TypeInfo> source;
					try
					{
						source = Assembly.GetExecutingAssembly().DefinedTypes.ToList();
					}
					catch (ReflectionTypeLoadException ex)
					{
						source = from t in ex.Types
							where t != null
							select t.GetTypeInfo();
					}
					_plugin = (BaseUnityPlugin)Chainloader.ManagerObject.GetComponent((Type)source.First([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (TypeInfo t) => t.IsClass && typeof(BaseUnityPlugin).IsAssignableFrom(t)));
				}
				return _plugin;
			}
		}

		[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)]
		private static object configSync
		{
			[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(2)]
			get
			{
				if (_configSync == null && hasConfigSync)
				{
					Type type = Assembly.GetExecutingAssembly().GetType("ServerSync.ConfigSync");
					if ((object)type != null)
					{
						_configSync = Activator.CreateInstance(type, plugin.Info.Metadata.GUID + " CreatureManager");
						type.GetField("CurrentVersion").SetValue(_configSync, plugin.Info.Metadata.Version.ToString());
						type.GetProperty("IsLocked").SetValue(_configSync, true);
					}
					else
					{
						hasConfigSync = false;
					}
				}
				return _configSync;
			}
		}

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

		public Creature(AssetBundle bundle, string prefabName)
			: this(PrefabManager.RegisterPrefab(bundle, prefabName))
		{
		}

		public Creature(GameObject creature)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			Prefab = creature;
			registeredCreatures.Add(this);
			CanBeTamed = Object.op_Implicit((Object)(object)creature.GetComponent<Tameable>());
			FoodItems = string.Join(",", (from i in creature.GetComponent<MonsterAI>()?.m_consumeItems
				where Object.op_Implicit((Object)(object)i.m_itemData.m_dropPrefab)
				select ((Object)i.m_itemData.m_dropPrefab).name) ?? Enumerable.Empty<string>());
		}

		public LocalizeKey Localize()
		{
			return new LocalizeKey(Prefab.GetComponent<Character>().m_name);
		}

		internal static void Patch_FejdStartup()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Expected O, but got Unknown
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Expected O, but got Unknown
			//IL_0685: Unknown result type (might be due to invalid IL or missing references)
			//IL_068f: Expected O, but got Unknown
			Type type = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (Assembly a) => a.GetName().Name == "ConfigurationManager")?.GetType("ConfigurationManager.ConfigurationManager");
			configManager = ((type == null) ? null : Chainloader.ManagerObject.GetComponent(type));
			if (!TomlTypeConverter.CanConvert(typeof(Range)))
			{
				TomlTypeConverter.AddConverter(typeof(Range), new TypeConverter
				{
					ConvertToObject = [<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (string s, Type _) =>
					{
						Match match = Regex.Match(s, "^(-?\\d+(?:\\.\\d*)?)\\s*-\\s*(-?\\d+(?:\\.\\d*)?)$");
						return match.Success ? new Range(float.Parse(match.Groups[1].Value), float.Parse(match.Groups[2].Value)) : default(Range);
					},
					ConvertToString = [<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (object obj, Type _) =>
					{
						Range range = (Range)obj;
						return $"{range.min} - {range.max}";
					}
				});
			}
			bool saveOnConfigSet = plugin.Config.SaveOnConfigSet;
			plugin.Config.SaveOnConfigSet = false;
			foreach (Creature registeredCreature in registeredCreatures)
			{
				Creature creature = registeredCreature;
				CreatureConfig creatureConfig2 = (creatureConfigs[creature] = new CreatureConfig());
				CreatureConfig cfg = creatureConfig2;
				string name2 = creature.Prefab.GetComponent<Character>().m_name;
				string englishName = new Regex("['[\"\\]]").Replace(english.Localize(name2), "").Trim();
				string localizedName = Localization.instance.Localize(name2).Trim();
				int order = 0;
				ConfigurationManagerAttributes tameConfigVisibility = new ConfigurationManagerAttributes();
				config<Toggle>(cfg.CanBeTamed, () => (!creature.CanBeTamed) ? Toggle.Off : Toggle.On, delegate
				{
					tameConfigVisibility.Browsable = cfg.CanBeTamed.get() == Toggle.On;
					reloadConfigDisplay();
					updateAI();
				}, "Can be tamed", "Decides, if the creature can be tamed.");
				tameConfigVisibility.Browsable = cfg.CanBeTamed.get() == Toggle.On;
				configWithDesc<string>(cfg.ConsumesItemName, [<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] () => creature.FoodItems, updateAI, "Food items", new ConfigDescription("The items the creature consumes to get tame.", (AcceptableValueBase)null, new object[1] { tameConfigVisibility }));
				ConfigurationManagerAttributes spawnConfigVisibility = new ConfigurationManagerAttributes();
				ConfigurationManagerAttributes dropConfigVisibility = new ConfigurationManagerAttributes();
				config<SpawnOption>(cfg.Spawn, () => creature.CanSpawn ? SpawnOption.Default : SpawnOption.Disabled, delegate
				{
					spawnConfigVisibility.Browsable = cfg.Spawn.get() == SpawnOption.Custom;
					reloadConfigDisplay();
					updateAllSpawnConfigs();
				}, "Spawn", "Configures the spawn for the creature.");
				spawnConfigVisibility.Browsable = cfg.Spawn.get() == SpawnOption.Custom;
				spawnConfig<SpawnTime>(cfg.SpecificSpawnTime, () => creature.SpecificSpawnTime, "Spawn time", "Configures the time of day for the creature to spawn.");
				spawnConfig<Range>(cfg.RequiredAltitude, () => creature.RequiredAltitude, "Required altitude", "Configures the altitude required for the creature to spawn.");
				spawnConfig<Range>(cfg.RequiredOceanDepth, () => creature.RequiredOceanDepth, "Required ocean depth", "Configures the ocean depth required for the creature to spawn.");
				spawnConfig<GlobalKey>(cfg.RequiredGlobalKey, () => creature.RequiredGlobalKey, "Required global key", "Configures the global key required for the creature to spawn.");
				spawnConfig<Range>(cfg.GroupSize, () => creature.GroupSize, "Group size", "Configures the size of the groups in which the creature spawns.");
				spawnConfig<Biome>(cfg.Biome, () => creature.Biome, "Biome", "Configures the biome required for the creature to spawn.");
				spawnConfig<SpawnArea>(cfg.SpecificSpawnArea, () => creature.SpecificSpawnArea, "Spawn area", "Configures if the creature spawns more towards the center or the edge of the biome.");
				spawnConfig<Weather>(cfg.RequiredWeather, () => creature.RequiredWeather, "Required weather", "Configures the weather required for the creature to spawn.");
				spawnConfig<float>(cfg.SpawnAltitude, () => creature.SpawnAltitude, "Spawn altitude", "Configures the height from the ground in which the creature will spawn.");
				spawnConfig<Toggle>(cfg.CanHaveStars, () => (!creature.CanHaveStars) ? Toggle.Off : Toggle.On, "Can have stars", "If the creature can have stars.");
				spawnConfig<Toggle>(cfg.AttackImmediately, () => (!creature.AttackImmediately) ? Toggle.Off : Toggle.On, "Hunt player", "Makes the creature immediately hunt down the player after it spawns.");
				spawnConfig<int>(cfg.CheckSpawnInterval, () => creature.CheckSpawnInterval, "Maximum spawn interval", "Configures the timespan that Valheim has to make the creature spawn.");
				spawnConfig<float>(cfg.SpawnChance, () => creature.SpawnChance, "Spawn chance", "Sets the chance for the creature to be spawned, every time Valheim checks the spawn.");
				spawnConfig<Forest>(cfg.ForestSpawn, () => creature.ForestSpawn, "Forest condition", "If the creature can spawn in forests or cannot spawn in forests. Or both.");
				spawnConfig<int>(cfg.Maximum, () => creature.Maximum, "Maximum creature count", "The maximum number of this creature near the player, before Valheim stops spawning it in. Setting this lower than the upper limit of the group size does not make sense.");
				config<DropOption>(cfg.Drops, () => DropOption.Default, delegate
				{
					dropConfigVisibility.Browsable = cfg.Drops.get() == DropOption.Custom;
					reloadConfigDisplay();
					DropList.UpdateDrops(creature);
				}, "Drops", "Configures the drops for the creature.");
				dropConfigVisibility.Browsable = cfg.Drops.get() == DropOption.Custom;
				configWithDesc<string>(cfg.CustomDrops, [<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] () => new DropList.SerializedDrops(creature.Drops, creature).ToString(), delegate
				{
					DropList.UpdateDrops(creature);
				}, "Drop config", new ConfigDescription("", (AcceptableValueBase)null, new object[1] { dropConfigVisibility }));
				void config<T>([<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(new byte[] { 1, 0 })] CustomConfig<T> customConfig, [<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(new byte[] { 1, 0 })] Func<T> getter, Action configChanged, string name, string desc)
				{
					//IL_000e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0018: Expected O, but got Unknown
					configWithDesc<T>(customConfig, getter, configChanged, name, new ConfigDescription(desc, (AcceptableValueBase)null, Array.Empty<object>()));
				}
				void configWithDesc<T>([<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(new byte[] { 1, 0 })] CustomConfig<T> customConfig, [<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(new byte[] { 1, 0 })] Func<T> getter, Action configChanged, string name, ConfigDescription desc)
				{
					//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
					//IL_00ed: Expected O, but got Unknown
					if (creature.ConfigurationEnabled)
					{
						customConfig.config = pluginConfig(englishName, name, getter(), new ConfigDescription(desc.Description, desc.AcceptableValues, desc.Tags.Concat(new ConfigurationManagerAttributes[1]
						{
							new ConfigurationManagerAttributes
							{
								Order = (order -= 1),
								CustomDrawer = ((customConfig == cfg.CustomDrops) ? new Action<ConfigEntryBase>(drawConfigTable) : ((typeof(T) == typeof(Range)) ? new Action<ConfigEntryBase>(drawRange) : null)),
								Category = localizedName
							}
						}).ToArray()));
						customConfig.config.SettingChanged += [<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (object _, EventArgs _) =>
						{
							configChanged();
						};
						customConfig.get = [<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] () => customConfig.config.Value;
					}
					else
					{
						customConfig.get = getter;
					}
				}
				void spawnConfig<T>([<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(new byte[] { 1, 0 })] CustomConfig<T> customConfig, [<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(new byte[] { 1, 0 })] Func<T> getter, string name, string desc, [<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)] AcceptableValueBase acceptableValues = null)
				{
					//IL_0028: Unknown result type (might be due to invalid IL or missing references)
					//IL_0032: Expected O, but got Unknown
					configWithDesc<T>(customConfig, getter, updateAllSpawnConfigs, name, new ConfigDescription(desc, acceptableValues, new object[1] { spawnConfigVisibility }));
				}
				void updateAI()
				{
					if (Object.op_Implicit((Object)(object)ObjectDB.instance))
					{
						BaseAI[] array2 = Object.FindObjectsOfType<BaseAI>();
						foreach (BaseAI ai in array2)
						{
							creature.updateAi(ai);
						}
						creature.updateAi(creature.Prefab.GetComponent<BaseAI>());
					}
				}
				void updateAllSpawnConfigs()
				{
					SpawnSystem[] array = Object.FindObjectsOfType<SpawnSystem>();
					for (int i = 0; i < array.Length; i++)
					{
						foreach (SpawnSystemList spawnList in array[i].m_spawnLists)
						{
							foreach (SpawnData spawner in spawnList.m_spawners)
							{
								if ((Object)(object)creature.Prefab == (Object)(object)spawner.m_prefab)
								{
									creature.updateSpawnData(spawner);
								}
							}
						}
					}
				}
			}
			if (saveOnConfigSet)
			{
				plugin.Config.SaveOnConfigSet = true;
				plugin.Config.Save();
			}
			static void reloadConfigDisplay()
			{
				object obj2 = configManager?.GetType().GetProperty("DisplayingWindow").GetValue(configManager);
				if (obj2 is bool && (bool)obj2)
				{
					configManager.GetType().GetMethod("BuildSettingList").Invoke(configManager, Array.Empty<object>());
				}
			}
		}

		private static void drawRange(ConfigEntryBase cfg)
		{
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Expected O, but got Unknown
			bool valueOrDefault = cfg.Description.Tags.Select([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (object a) => (!(a.GetType().Name == "ConfigurationManagerAttributes")) ? null : ((bool?)a.GetType().GetField("ReadOnly")?.GetValue(a))).FirstOrDefault((bool? v) => v.HasValue).GetValueOrDefault();
			ConfigEntry<Range> val = (ConfigEntry<Range>)(object)cfg;
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			float.TryParse(GUILayout.TextField(val.Value.min.ToString(CultureInfo.InvariantCulture), Array.Empty<GUILayoutOption>()), out var result);
			GUILayout.Label(" - ", new GUIStyle(GUI.skin.label)
			{
				fixedWidth = 14f
			}, Array.Empty<GUILayoutOption>());
			float.TryParse(GUILayout.TextField(val.Value.max.ToString(CultureInfo.InvariantCulture), Array.Empty<GUILayoutOption>()), out var result2);
			GUILayout.EndHorizontal();
			if (!valueOrDefault && (Math.Abs(val.Value.min - result) > 1E-05f || Math.Abs(val.Value.max - result2) > 1E-05f))
			{
				val.Value = new Range(result, result2);
			}
		}

		private static void drawConfigTable(ConfigEntryBase cfg)
		{
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Expected O, but got Unknown
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Expected O, but got Unknown
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Expected O, but got Unknown
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Expected O, but got Unknown
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Expected O, but got Unknown
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: Unknown result type (might be due to invalid IL or missing references)
			//IL_027b: Expected O, but got Unknown
			//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: Expected O, but got Unknown
			//IL_032f: Unknown result type (might be due to invalid IL or missing references)
			//IL_033e: Expected O, but got Unknown
			//IL_0374: Unknown result type (might be due to invalid IL or missing references)
			//IL_0383: Expected O, but got Unknown
			//IL_03a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0424: Unknown result type (might be due to invalid IL or missing references)
			//IL_0429: Unknown result type (might be due to invalid IL or missing references)
			//IL_043e: Expected O, but got Unknown
			bool valueOrDefault = cfg.Description.Tags.Select([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (object a) => (!(a.GetType().Name == "ConfigurationManagerAttributes")) ? null : ((bool?)a.GetType().GetField("ReadOnly")?.GetValue(a))).FirstOrDefault((bool? v) => v.HasValue).GetValueOrDefault();
			List<KeyValuePair<string, Drop>> list = new List<KeyValuePair<string, Drop>>();
			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(Array.Empty<GUILayoutOption>());
			foreach (KeyValuePair<string, Drop> drop in new DropList.SerializedDrops((string)cfg.BoxedValue).Drops)
			{
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				int num2 = Mathf.RoundToInt(drop.Value.Amount.min);
				if (int.TryParse(GUILayout.TextField(num2.ToString(), new GUIStyle(GUI.skin.textField)
				{
					fixedWidth = 35f
				}, Array.Empty<GUILayoutOption>()), out var result) && result != num2 && !valueOrDefault)
				{
					num2 = result;
					flag = true;
				}
				GUILayout.Label(" - ", new GUIStyle(GUI.skin.label)
				{
					fixedWidth = 14f
				}, Array.Empty<GUILayoutOption>());
				int num3 = Mathf.RoundToInt(drop.Value.Amount.max);
				if (int.TryParse(GUILayout.TextField(num3.ToString(), new GUIStyle(GUI.skin.textField)
				{
					fixedWidth = 35f
				}, Array.Empty<GUILayoutOption>()), out var result2) && result2 != num3 && !valueOrDefault)
				{
					num3 = result2;
					flag = true;
				}
				GUILayout.Label(" ", new GUIStyle(GUI.skin.label)
				{
					fixedWidth = 10f
				}, Array.Empty<GUILayoutOption>());
				string text = GUILayout.TextField(drop.Key, new GUIStyle(GUI.skin.textField)
				{
					fixedWidth = num - 35 - 14 - 35 - 10 - 21 - 18
				}, Array.Empty<GUILayoutOption>());
				string text2 = (valueOrDefault ? drop.Key : text);
				flag = flag || text2 != drop.Key;
				bool num4 = GUILayout.Button("x", new GUIStyle(GUI.skin.button)
				{
					fixedWidth = 21f
				}, Array.Empty<GUILayoutOption>()) && !valueOrDefault;
				GUILayout.EndHorizontal();
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				float num5 = drop.Value.DropChance;
				if (float.TryParse(GUILayout.TextField(num5.ToString(CultureInfo.InvariantCulture), new GUIStyle(GUI.skin.textField)
				{
					fixedWidth = 45f
				}, Array.Empty<GUILayoutOption>()), out var result3) && Math.Abs(result3 - num5) > 1E-05f && !valueOrDefault)
				{
					num5 = result3;
					flag = true;
				}
				GUILayout.Label("% ", Array.Empty<GUILayoutOption>());
				string tooltip = GUI.tooltip;
				bool flag2 = drop.Value.MultiplyDropByLevel;
				bool flag3 = GUILayout.Toggle(flag2, new GUIContent(flag2 ? "per level" : "fixed", "Loot is multiplied by the creature's level."), Array.Empty<GUILayoutOption>());
				if (flag3 != flag2 && !valueOrDefault)
				{
					flag2 = flag3;
					flag = true;
				}
				bool flag4 = drop.Value.DropOnePerPlayer;
				bool flag5 = GUILayout.Toggle(flag4, new GUIContent(flag4 ? "per player" : "independent", "Drops one per player."), Array.Empty<GUILayoutOption>());
				if (flag5 != flag4 && !valueOrDefault)
				{
					flag4 = flag5;
					flag = true;
				}
				if (GUI.tooltip != tooltip)
				{
					Vector3 mousePosition = Input.mousePosition;
					GUI.Label(new Rect(mousePosition.x, mousePosition.y, 100f, 35f), GUI.tooltip);
				}
				if (num4)
				{
					flag = true;
				}
				else
				{
					Drop value = new Drop
					{
						Amount = new Range(num2, num3),
						DropChance = num5,
						MultiplyDropByLevel = flag2,
						DropOnePerPlayer = flag4
					};
					list.Add(new KeyValuePair<string, Drop>(text2, value));
				}
				if (GUILayout.Button("+", new GUIStyle(GUI.skin.button)
				{
					fixedWidth = 21f
				}, Array.Empty<GUILayoutOption>()) && !valueOrDefault)
				{
					flag = true;
					list.Add(new KeyValuePair<string, Drop>("", new Drop()));
				}
				GUILayout.EndHorizontal();
			}
			GUILayout.EndVertical();
			if (flag)
			{
				cfg.BoxedValue = new DropList.SerializedDrops(list).ToString();
			}
		}

		private void updateAi(BaseAI ai)
		{
			CreatureConfig creatureConfig = creatureConfigs[this];
			if (Object.op_Implicit((Object)(object)((Component)ai).GetComponent<Tameable>()) != (creatureConfig.CanBeTamed.get() == Toggle.On))
			{
				if (creatureConfig.CanBeTamed.get() == Toggle.On)
				{
					ai.m_tamable = ((Component)ai).gameObject.AddComponent<Tameable>();
				}
				else
				{
					Object.Destroy((Object)(object)ai.m_tamable);
					ai.m_tamable = null;
				}
			}
			MonsterAI val = (MonsterAI)(object)((ai is MonsterAI) ? ai : null);
			if (val == null)
			{
				return;
			}
			val.m_consumeItems.Clear();
			string[] array = creatureConfig.ConsumesItemName.get().Split(new char[1] { ',' });
			foreach (string text in array)
			{
				GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(text.Trim());
				ItemDrop val2 = ((itemPrefab != null) ? itemPrefab.GetComponent<ItemDrop>() : null);
				if (val2 != null)
				{
					val.m_consumeItems.Add(val2);
				}
			}
		}

		internal static void UpdateCreatureAis(ObjectDB __instance)
		{
			foreach (Creature registeredCreature in registeredCreatures)
			{
				registeredCreature.updateAi(registeredCreature.Prefab.GetComponent<BaseAI>());
			}
		}

		private void updateSpawnData(SpawnData spawnData)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			CreatureConfig cfg = creatureConfigs[this];
			spawnData.m_enabled = cfg.Spawn.get() != SpawnOption.Disabled;
			spawnData.m_biome = cfg.Biome.get();
			SpawnData val = spawnData;
			val.m_biomeArea = (BiomeArea)(cfg.SpecificSpawnArea.get() switch
			{
				SpawnArea.Center => 2, 
				SpawnArea.Edge => 1, 
				_ => 3, 
			});
			spawnData.m_maxSpawned = cfg.Maximum.get();
			spawnData.m_spawnInterval = cfg.CheckSpawnInterval.get();
			spawnData.m_spawnChance = cfg.SpawnChance.get();
			spawnData.m_requiredGlobalKey = ((InternalName)typeof(GlobalKey).GetMember(cfg.RequiredGlobalKey.get().ToString())[0].GetCustomAttributes(typeof(InternalName)).First()).internalName;
			spawnData.m_requiredEnvironments = (from Weather w in Enum.GetValues(typeof(Weather))
				where (w & cfg.RequiredWeather.get()) != 0
				select ((InternalName)typeof(Weather).GetMember(w.ToString())[0].GetCustomAttributes(typeof(InternalName)).First()).internalName).ToList();
			spawnData.m_groupSizeMin = (int)cfg.GroupSize.get().min;
			spawnData.m_groupSizeMax = (int)cfg.GroupSize.get().max;
			val = spawnData;
			SpawnTime spawnTime = cfg.SpecificSpawnTime.get();
			bool spawnAtNight = (uint)(spawnTime - 1) <= 1u;
			val.m_spawnAtNight = spawnAtNight;
			val = spawnData;
			spawnTime = cfg.SpecificSpawnTime.get();
			spawnAtNight = ((spawnTime == SpawnTime.Day || spawnTime == SpawnTime.Always) ? true : false);
			val.m_spawnAtDay = spawnAtNight;
			spawnData.m_minAltitude = cfg.RequiredAltitude.get().min;
			spawnData.m_maxAltitude = cfg.RequiredAltitude.get().max;
			val = spawnData;
			Forest forest = cfg.ForestSpawn.get();
			spawnAtNight = ((forest == Forest.Yes || forest == Forest.Both) ? true : false);
			val.m_inForest = spawnAtNight;
			val = spawnData;
			forest = cfg.ForestSpawn.get();
			spawnAtNight = (uint)(forest - 1) <= 1u;
			val.m_outsideForest = spawnAtNight;
			spawnData.m_minOceanDepth = cfg.RequiredOceanDepth.get().min;
			spawnData.m_maxOceanDepth = cfg.RequiredOceanDepth.get().max;
			spawnData.m_huntPlayer = cfg.AttackImmediately.get() == Toggle.On;
			spawnData.m_groundOffset = cfg.SpawnAltitude.get();
			spawnData.m_maxLevel = ((cfg.CanHaveStars.get() != 0) ? 1 : 3);
		}

		[HarmonyPriority(700)]
		internal static void AddToSpawnSystem(SpawnSystem __instance)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			SpawnSystemList val = __instance.m_spawnLists.First();
			foreach (SpawnData lastRegisteredSpawn in lastRegisteredSpawns)
			{
				val.m_spawners.Remove(lastRegisteredSpawn);
			}
			lastRegisteredSpawns.Clear();
			foreach (Creature registeredCreature in registeredCreatures)
			{
				SpawnData val2 = new SpawnData
				{
					m_name = ((Object)registeredCreature.Prefab).name,
					m_prefab = registeredCreature.Prefab
				};
				registeredCreature.updateSpawnData(val2);
				lastRegisteredSpawns.Add(val2);
				val.m_spawners.Add(val2);
			}
		}

		private static ConfigEntry<T> pluginConfig<[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)] T>(string group, string name, T value, ConfigDescription description)
		{
			ConfigEntry<T> val = plugin.Config.Bind<T>(group, name, value, description);
			configSync?.GetType().GetMethod("AddConfigEntry").MakeGenericMethod(typeof(T))
				.Invoke(configSync, new object[1] { val });
			return val;
		}

		private static ConfigEntry<T> pluginConfig<[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(2)] T>(string group, string name, T value, string description)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			return pluginConfig(group, name, value, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()));
		}
	}
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	[PublicAPI]
	public 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));
				}
			}
		}
	}
	[<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(1)]
	[<5ea91132-7291-4072-bba1-fdb04647c6e6>Nullable(0)]
	public static class PrefabManager
	{
		[<5ea91132-7291-4072-bba1-fdb04647c6e6>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> prefabs;

		static PrefabManager()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Expected O, but got Unknown
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Expected O, but got Unknown
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Expected O, but got Unknown
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Expected O, but got Unknown
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Expected O, but got Unknown
			bundleCache = new Dictionary<BundleId, AssetBundle>();
			prefabs = new List<GameObject>();
			Harmony val = new Harmony("org.bepinex.helpers.CreatureManager");
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ZNetScene), "Awake", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PrefabManager), "Patch_ZNetSceneAwake", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ZNetScene), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Creature.DropList), "AddDropsToCreature", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(SpawnSystem), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Creature), "AddToSpawnSystem", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ObjectDB), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Creature), "UpdateCreatureAis", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(FejdStartup), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Creature), "Patch_FejdStartup", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Localization), "LoadCSV", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(LocalizeKey), "AddLocalizedKeys", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			if (!typeof(Biome).GetCustomAttributes(typeof(FlagsAttribute), inherit: false).Any())
			{
				val.Patch((MethodBase)AccessTools.Method(typeof(Biome).GetType(), "GetCustomAttributes", new Type[2]
				{
					typeof(Type),
					typeof(bool)
				}, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PrefabManager), "BiomeIsFlags", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
		}

		private static void BiomeIsFlags(Type __instance, Type attributeType, ref object[] __result)
		{
			if (__instance == typeof(Biome) && attributeType == typeof(FlagsAttribute))
			{
				__result = new object[1]
				{
					new FlagsAttribute()
				};
			}
		}

		public static AssetBundle RegisterAssetBundle(string assetBundleFileName, string folderName = "assets")
		{
			BundleId bundleId = default(BundleId);
			bundleId.assetBundleFileName = assetBundleFileName;
			bundleId.folderName = folderName;
			BundleId key = bundleId;
			if (!bundleCache.TryGetValue(key, out var value))
			{
				Dictionary<BundleId, AssetBundle> dictionary = bundleCache;
				AssetBundle? obj = ((IEnumerable<AssetBundle>)Resources.FindObjectsOfTypeAll<AssetBundle>()).FirstOrDefault((Func<AssetBundle, bool>)([<702532f4-32dc-46a6-8d9a-cabd38c9424b>NullableContext(0)] (AssetBundle a) => ((Object)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 GameObject RegisterPrefab(AssetBundle assets, string prefabName)
		{
			GameObject val = assets.LoadAsset<GameObject>(prefabName);
			prefabs.Add(val);
			return val;
		}

		[HarmonyPriority(700)]
		private static void Patch_ZNetSceneAwake(ZNetScene __instance)
		{
			foreach (GameObject prefab in prefabs)
			{
				__instance.m_prefabs.Add(prefab);
			}
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[<f0995e58-882f-40c1-9c2c-1fd1d79bbe54>Embedded]
	internal sealed class <f0995e58-882f-40c1-9c2c-1fd1d79bbe54>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[<f0995e58-882f-40c1-9c2c-1fd1d79bbe54>Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	[CompilerGenerated]
	internal sealed class <68981f5c-6a43-4b32-90d8-46e25679519d>NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public <68981f5c-6a43-4b32-90d8-46e25679519d>NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public <68981f5c-6a43-4b32-90d8-46e25679519d>NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[<f0995e58-882f-40c1-9c2c-1fd1d79bbe54>Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	[CompilerGenerated]
	internal sealed class <32b27d4b-cccc-4fc0-bc4e-1fac6f0cf550>NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public <32b27d4b-cccc-4fc0-bc4e-1fac6f0cf550>NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[<f0995e58-882f-40c1-9c2c-1fd1d79bbe54>Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	[CompilerGenerated]
	internal sealed class <2b91c8cc-4e65-424c-b956-dd317913890d>RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public <2b91c8cc-4e65-424c-b956-dd317913890d>RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ServerSync
{
	[<68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(0)]
	[PublicAPI]
	[<32b27d4b-cccc-4fc0-bc4e-1fac6f0cf550>NullableContext(1)]
	internal abstract class OwnConfigEntryBase
	{
		[<68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(2)]
		public object LocalBaseValue;

		public bool SynchronizedConfig = true;

		public abstract ConfigEntryBase BaseConfig { get; }
	}
	[PublicAPI]
	[<32b27d4b-cccc-4fc0-bc4e-1fac6f0cf550>NullableContext(1)]
	[<68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(0)]
	internal class SyncedConfigEntry<[<68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(2)] T> : OwnConfigEntryBase
	{
		public readonly ConfigEntry<T> SourceConfig;

		public override ConfigEntryBase BaseConfig => (ConfigEntryBase)(object)SourceConfig;

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

		public SyncedConfigEntry(ConfigEntry<T> sourceConfig)
		{
			SourceConfig = sourceConfig;
		}

		public void AssignLocalValue(T value)
		{
			if (LocalBaseValue == null)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	[<68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(0)]
	[<32b27d4b-cccc-4fc0-bc4e-1fac6f0cf550>NullableContext(2)]
	internal abstract class CustomSyncedValueBase
	{
		public object LocalBaseValue;

		[<68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(1)]
		public readonly string Identifier;

		[<68981f5c-6a43-4b32-90d8-46e25679519d>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;

		[<32b27d4b-cccc-4fc0-bc4e-1fac6f0cf550>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;
			};
		}
	}
	[PublicAPI]
	[<68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(0)]
	[<32b27d4b-cccc-4fc0-bc4e-1fac6f0cf550>NullableContext(1)]
	internal sealed class CustomSyncedValue<[<68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(2)] T> : CustomSyncedValueBase
	{
		public T Value
		{
			get
			{
				return (T)base.BoxedValue;
			}
			set
			{
				base.BoxedValue = value;
			}
		}

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

		public void AssignLocalValue(T value)
		{
			if (localIsOwner)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	internal class ConfigurationManagerAttributes
	{
		[UsedImplicitly]
		public bool? ReadOnly = false;
	}
	[<68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(0)]
	[<32b27d4b-cccc-4fc0-bc4e-1fac6f0cf550>NullableContext(1)]
	[PublicAPI]
	internal class ConfigSync
	{
		[<32b27d4b-cccc-4fc0-bc4e-1fac6f0cf550>NullableContext(0)]
		[HarmonyPatch(typeof(ZRpc), "HandlePackage")]
		private static class SnatchCurrentlyHandlingRPC
		{
			[<68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(2)]
			public static ZRpc currentRpc;

			[<32b27d4b-cccc-4fc0-bc4e-1fac6f0cf550>NullableContext(1)]
			[HarmonyPrefix]
			private static void Prefix(ZRpc __instance)
			{
				currentRpc = __instance;
			}
		}

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

		[<32b27d4b-cccc-4fc0-bc4e-1fac6f0cf550>NullableContext(0)]
		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		private static class RegisterClientRPCPatch
		{
			[HarmonyPostfix]
			[<32b27d4b-cccc-4fc0-bc4e-1fac6f0cf550>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", (Action<ZRpc, ZPackage>)configSync.RPC_FromServerConfigSync);
				}
			}
		}

		[<32b27d4b-cccc-4fc0-bc4e-1fac6f0cf550>NullableContext(0)]
		private class ParsedConfigs
		{
			[<68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(new byte[] { 1, 1, 2 })]
			public readonly Dictionary<OwnConfigEntryBase, object> configValues = new Dictionary<OwnConfigEntryBase, object>();

			[<68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(new byte[] { 1, 1, 2 })]
			public readonly Dictionary<CustomSyncedValueBase, object> customValues = new Dictionary<CustomSyncedValueBase, object>();
		}

		[<32b27d4b-cccc-4fc0-bc4e-1fac6f0cf550>NullableContext(0)]
		[HarmonyPatch(typeof(ZNet), "Shutdown")]
		private class ResetConfigsOnShutdown
		{
			[HarmonyPostfix]
			private static void Postfix()
			{
				ProcessingServerUpdate = true;
				foreach (ConfigSync configSync in configSyncs)
				{
					configSync.resetConfigsFromServer();
					configSync.IsSourceOfTruth = true;
					configSync.InitialSyncDone = false;
				}
				ProcessingServerUpdate = false;
			}
		}

		[<68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(0)]
		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		private class SendConfigsAfterLogin
		{
			[<68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(0)]
			private class BufferingSocket : ISocket
			{
				public volatile bool finished = false;

				public volatile int versionMatchQueued = -1;

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

				public readonly ISocket Original;

				public BufferingSocket(ISocket original)
				{
					Original = original;
				}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

				public void Send(ZPackage pkg)
				{
					//IL_0057: Unknown result type (might be due to invalid IL or missing references)
					//IL_005d: Expected O, but got Unknown
					int pos = pkg.GetPos();
					pkg.SetPos(0);
					int num = pkg.ReadInt();
					if ((num == StringExtensionMethods.GetStableHashCode("PeerInfo") || num == StringExtensionMethods.GetStableHashCode("RoutedRPC") || num == StringExtensionMethods.GetStableHashCode("ZDOData")) && !finished)
					{
						ZPackage val = new ZPackage(pkg.GetArray());
						val.SetPos(pos);
						Package.Add(val);
					}
					else
					{
						pkg.SetPos(pos);
						Original.Send(pkg);
					}
				}
			}

			[HarmonyPrefix]
			[HarmonyPriority(800)]
			private static void Prefix([<68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(new byte[] { 2, 1, 1 })] ref Dictionary<Assembly, BufferingSocket> __state, ZNet __instance, ZRpc rpc)
			{
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Invalid comparison between Unknown and I4
				if (__instance.IsServer())
				{
					BufferingSocket value = new BufferingSocket(rpc.GetSocket());
					AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc, value);
					object? obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
					ZNetPeer val = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
					if (val != null && (int)ZNet.m_onlineBackend > 0)
					{
						AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket").SetValue(val, value);
					}
					if (__state == null)
					{
						__state = new Dictionary<Assembly, BufferingSocket>();
					}
					__state[Assembly.GetExecutingAssembly()] = value;
				}
			}

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

		[<68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(0)]
		private class PackageEntry
		{
			public string section = null;

			public string key = null;

			public Type type = null;

			[<68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(2)]
			public object value;
		}

		[HarmonyPatch(typeof(ConfigEntryBase), "GetSerializedValue")]
		[<32b27d4b-cccc-4fc0-bc4e-1fac6f0cf550>NullableContext(0)]
		private static class PreventSavingServerInfo
		{
			[HarmonyPrefix]
			[<32b27d4b-cccc-4fc0-bc4e-1fac6f0cf550>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;
			}
		}

		[<32b27d4b-cccc-4fc0-bc4e-1fac6f0cf550>NullableContext(0)]
		[HarmonyPatch(typeof(ConfigEntryBase), "SetSerializedValue")]
		private static class PreventConfigRereadChangingValues
		{
			[HarmonyPrefix]
			[<32b27d4b-cccc-4fc0-bc4e-1fac6f0cf550>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((object)$"Config value of setting \"{__instance.Definition}\" could not be parsed and will be ignored. Reason: {ex.Message}; Value: {value}");
				}
				return false;
			}
		}

		[<68981f5c-6a43-4b32-90d8-46e25679519d>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;

		[<68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(2)]
		public string DisplayName;

		[<68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(2)]
		public string CurrentVersion;

		[<68981f5c-6a43-4b32-90d8-46e25679519d>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;

		[<68981f5c-6a43-4b32-90d8-46e25679519d>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[]>>();

		[<68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(new byte[] { 1, 0, 1 })]
		private readonly List<KeyValuePair<long, string>> cacheExpirations = new List<KeyValuePair<long, string>>();

		private static long packageCounter;

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

		public bool IsAdmin => lockExempt || isSourceOfTruth;

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

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


		[<68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(2)]
		[method: <32b27d4b-cccc-4fc0-bc4e-1fac6f0cf550>NullableContext(2)]
		[field: <68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(2)]
		public event Action<bool> SourceOfTruthChanged;

		[<68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(2)]
		[method: <32b27d4b-cccc-4fc0-bc4e-1fac6f0cf550>NullableContext(2)]
		[field: <68981f5c-6a43-4b32-90d8-46e25679519d>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<[<68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(2)] T>(ConfigEntry<T> configEntry)
		{
			OwnConfigEntryBase ownConfigEntryBase = configData((ConfigEntryBase)(object)configEntry);
			SyncedConfigEntry<T> syncedEntry = ownConfigEntryBase as SyncedConfigEntry<T>;
			if (syncedEntry == null)
			{
				syncedEntry = new SyncedConfigEntry<T>(configEntry);
				AccessTools.DeclaredField(typeof(ConfigDescription), "<Tags>k__BackingField").SetValue(((ConfigEntryBase)configEntry).Description, new object[1]
				{
					new ConfigurationManagerAttributes()
				}.Concat(((ConfigEntryBase)configEntry).Description.Tags ?? Array.Empty<object>()).Concat(new SyncedConfigEntry<T>[1] { syncedEntry }).ToArray());
				configEntry.SettingChanged += [<32b27d4b-cccc-4fc0-bc4e-1fac6f0cf550>NullableContext(0)] (object _, EventArgs _) =>
				{
					if (!ProcessingServerUpdate && syncedEntry.SynchronizedConfig)
					{
						Broadcast(ZRoutedRpc.Everybody, (ConfigEntryBase)configEntry);
					}
				};
				allConfigs.Add(syncedEntry);
			}
			return syncedEntry;
		}

		public SyncedConfigEntry<T> AddLockingConfigEntry<[<68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(0)] T>(ConfigEntry<T> lockingConfig) where T : IConvertible
		{
			if (lockedConfig != null)
			{
				throw new Exception("Cannot initialize locking ConfigEntry twice");
			}
			lockedConfig = AddConfigEntry<T>(lockingConfig);
			lockingConfig.SettingChanged += [<32b27d4b-cccc-4fc0-bc4e-1fac6f0cf550>NullableContext(0)] (object _, EventArgs _) =>
			{
				this.lockedConfigChanged?.Invoke();
			};
			return (SyncedConfigEntry<T>)lockedConfig;
		}

		internal void AddCustomValue(CustomSyncedValueBase customValue)
		{
			if (allCustomValues.Select([<32b27d4b-cccc-4fc0-bc4e-1fac6f0cf550>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([<32b27d4b-cccc-4fc0-bc4e-1fac6f0cf550>NullableContext(0)] (CustomSyncedValueBase v) => v.Priority));
			customValue.ValueChanged += delegate
			{
				if (!ProcessingServerUpdate)
				{
					Broadcast(ZRoutedRpc.Everybody, customValue);
				}
			};
		}

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

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

		private bool HandleConfigSyncRPC(long sender, ZPackage package, bool clientUpdate)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Expected O, but got Unknown
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Expected O, but got Unknown
			try
			{
				if (isServer && IsLocked)
				{
					ZRpc currentRpc = SnatchCurrentlyHandlingRPC.currentRpc;
					object obj;
					if (currentRpc == null)
					{
						obj = null;
					}
					else
					{
						ISocket socket = currentRpc.GetSocket();
						obj = ((socket != null) ? socket.GetHostName() : null);
					}
					string text = (string)obj;
					if (text != null)
					{
						MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
						SyncedList val = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
						if (!(((object)methodInfo == null) ? val.Contains(text) : ((bool)methodInfo.Invoke(ZNet.instance, new object[2] { val, text }))))
						{
							return false;
						}
					}
				}
				cacheExpirations.RemoveAll(([<68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(new byte[] { 0, 1 })] KeyValuePair<long, string> kv) =>
				{
					if (kv.Key < DateTimeOffset.Now.Ticks)
					{
						configValueCache.Remove(kv.Value);
						return true;
					}
					return false;
				});
				byte b = package.ReadByte();
				if ((b & 2u) != 0)
				{
					long num = package.ReadLong();
					string text2 = sender.ToString() + num;
					if (!configValueCache.TryGetValue(text2, out var value))
					{
						value = new SortedDictionary<int, byte[]>();
						configValueCache[text2] = value;
						cacheExpirations.Add(new KeyValuePair<long, string>(DateTimeOffset.Now.AddSeconds(60.0).Ticks, text2));
					}
					int key = package.ReadInt();
					int num2 = package.ReadInt();
					value.Add(key, package.ReadByteArray());
					if (value.Count < num2)
					{
						return false;
					}
					configValueCache.Remove(text2);
					package = new ZPackage(value.Values.SelectMany([<32b27d4b-cccc-4fc0-bc4e-1fac6f0cf550>NullableContext(0)] (byte[] a) => a).ToArray());
					b = package.ReadByte();
				}
				ProcessingServerUpdate = true;
				if ((b & 4u) != 0)
				{
					byte[] buffer = package.ReadByteArray();
					MemoryStream stream = new MemoryStream(buffer);
					MemoryStream memoryStream = new MemoryStream();
					using (DeflateStream deflateStream = new DeflateStream(stream, CompressionMode.Decompress))
					{
						deflateStream.CopyTo(memoryStream);
					}
					package = new ZPackage(memoryStream.ToArray());
					b = package.ReadByte();
				}
				if ((b & 1) == 0)
				{
					resetConfigsFromServer();
				}
				ParsedConfigs parsedConfigs = ReadConfigsFromPackage(package);
				ConfigFile val2 = null;
				bool saveOnConfigSet = false;
				foreach (KeyValuePair<OwnConfigEntryBase, object> configValue in parsedConfigs.configValues)
				{
					if (!isServer && configValue.Key.LocalBaseValue == null)
					{
						configValue.Key.LocalBaseValue = configValue.Key.BaseConfig.BoxedValue;
					}
					if (val2 == null)
					{
						val2 = configValue.Key.BaseConfig.ConfigFile;
						saveOnConfigSet = val2.SaveOnConfigSet;
						val2.SaveOnConfigSet = false;
					}
					configValue.Key.BaseConfig.BoxedValue = configValue.Value;
				}
				if (val2 != null)
				{
					val2.SaveOnConfigSet = saveOnConfigSet;
				}
				foreach (KeyValuePair<CustomSyncedValueBase, object> customValue in parsedConfigs.customValues)
				{
					if (!isServer)
					{
						CustomSyncedValueBase key2 = customValue.Key;
						if (key2.LocalBaseValue == null)
						{
							key2.LocalBaseValue = customValue.Key.BoxedValue;
						}
					}
					customValue.Key.BoxedValue = customValue.Value;
				}
				Debug.Log((object)string.Format("Received {0} configs and {1} custom values from {2} for mod {3}", parsedConfigs.configValues.Count, parsedConfigs.customValues.Count, (isServer || clientUpdate) ? $"client {sender}" : "the server", DisplayName ?? Name));
				if (!isServer)
				{
					serverLockedSettingChanged();
				}
				return true;
			}
			finally
			{
				ProcessingServerUpdate = false;
			}
		}

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

		private static bool isWritableConfig(OwnConfigEntryBase config)
		{
			ConfigSync configSync = configSyncs.FirstOrDefault([<32b27d4b-cccc-4fc0-bc4e-1fac6f0cf550>NullableContext(0)] (ConfigSync cs) => cs.allConfigs.Contains(config));
			if (configSync == null)
			{
				return true;
			}
			return configSync.IsSourceOfTruth || !config.SynchronizedConfig || config.LocalBaseValue == null || (!configSync.IsLocked && (config != configSync.lockedConfig || lockExempt));
		}

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

		private void resetConfigsFromServer()
		{
			ConfigFile val = null;
			bool saveOnConfigSet = false;
			foreach (OwnConfigEntryBase item in allConfigs.Where([<32b27d4b-cccc-4fc0-bc4e-1fac6f0cf550>NullableContext(0)] (OwnConfigEntryBase config) => config.LocalBaseValue != null))
			{
				if (val == null)
				{
					val = item.BaseConfig.ConfigFile;
					saveOnConfigSet = val.SaveOnConfigSet;
					val.SaveOnConfigSet = false;
				}
				item.BaseConfig.BoxedValue = item.LocalBaseValue;
				item.LocalBaseValue = null;
			}
			if (val != null)
			{
				val.SaveOnConfigSet = saveOnConfigSet;
			}
			foreach (CustomSyncedValueBase item2 in allCustomValues.Where([<32b27d4b-cccc-4fc0-bc4e-1fac6f0cf550>NullableContext(0)] (CustomSyncedValueBase config) => config.LocalBaseValue != null))
			{
				item2.BoxedValue = item2.LocalBaseValue;
				item2.LocalBaseValue = null;
			}
			lockedConfigChanged -= serverLockedSettingChanged;
			serverLockedSettingChanged();
		}

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

		private IEnumerator sendZPackage(long target, ZPackage package)
		{
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				return Enumerable.Empty<object>().GetEnumerator();
			}
			List<ZNetPeer> list = (List<ZNetPeer>)AccessTools.DeclaredField(typeof(ZRoutedRpc), "m_peers").GetValue(ZRoutedRpc.instance);
			if (target != ZRoutedRpc.Everybody)
			{
				list = list.Where([<32b27d4b-cccc-4fc0-bc4e-1fac6f0cf550>NullableContext(0)] (ZNetPeer p) => p.m_uid == target).ToList();
			}
			return sendZPackage(list, package);
		}

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

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

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

		[return: <68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(2)]
		private static OwnConfigEntryBase configData(ConfigEntryBase config)
		{
			return config.Description.Tags?.OfType<OwnConfigEntryBase>().SingleOrDefault();
		}

		[return: <68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(new byte[] { 2, 1 })]
		public static SyncedConfigEntry<T> ConfigData<[<68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(2)] T>(ConfigEntry<T> config)
		{
			return ((ConfigEntryBase)config).Description.Tags?.OfType<SyncedConfigEntry<T>>().SingleOrDefault();
		}

		private static T configAttribute<[<68981f5c-6a43-4b32-90d8-46e25679519d>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([<68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(new byte[] { 2, 1 })] IEnumerable<ConfigEntryBase> configs = null, [<68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(new byte[] { 2, 1 })] IEnumerable<CustomSyncedValueBase> customValues = null, [<68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(new byte[] { 2, 1 })] IEnumerable<PackageEntry> packageEntries = null, bool partial = true)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			List<ConfigEntryBase> list = configs?.Where([<32b27d4b-cccc-4fc0-bc4e-1fac6f0cf550>NullableContext(0)] (ConfigEntryBase config) => configData(config).SynchronizedConfig).ToList() ?? new List<ConfigEntryBase>();
			List<CustomSyncedValueBase> list2 = customValues?.ToList() ?? new List<CustomSyncedValueBase>();
			ZPackage val = new ZPackage();
			val.Write((byte)(partial ? 1 : 0));
			val.Write(list.Count + list2.Count + (packageEntries?.Count() ?? 0));
			foreach (PackageEntry item in packageEntries ?? Array.Empty<PackageEntry>())
			{
				AddEntryToPackage(val, item);
			}
			foreach (CustomSyncedValueBase item2 in list2)
			{
				AddEntryToPackage(val, new PackageEntry
				{
					section = "Internal",
					key = item2.Identifier,
					type = item2.Type,
					value = item2.BoxedValue
				});
			}
			foreach (ConfigEntryBase item3 in list)
			{
				AddEntryToPackage(val, new PackageEntry
				{
					section = item3.Definition.Section,
					key = item3.Definition.Key,
					type = configType(item3),
					value = item3.BoxedValue
				});
			}
			return val;
		}

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

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

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

		private static object ReadValueWithTypeFromZPackage(ZPackage package, Type type)
		{
			if ((object)type != null && type.IsValueType && !type.IsPrimitive && !type.IsEnum)
			{
				FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				int num = package.ReadInt();
				if (num != fields.Length)
				{
					throw new InvalidDeserializationTypeException
					{
						received = $"(field count: {num})",
						expected = $"(field count: {fields.Length})"
					};
				}
				object uninitializedObject = FormatterServices.GetUninitializedObject(type);
				FieldInfo[] array = fields;
				foreach (FieldInfo fieldInfo in array)
				{
					string text = package.ReadString();
					if (text != GetZPackageTypeString(fieldInfo.FieldType))
					{
						throw new InvalidDeserializationTypeException
						{
							received = text,
							expected = GetZPackageTypeString(fieldInfo.FieldType),
							field = fieldInfo.Name
						};
					}
					fieldInfo.SetValue(uninitializedObject, ReadValueWithTypeFromZPackage(package, fieldInfo.FieldType));
				}
				return uninitializedObject;
			}
			if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Dictionary<, >))
			{
				int num2 = package.ReadInt();
				IDictionary dictionary = (IDictionary)Activator.CreateInstance(type);
				Type type2 = typeof(KeyValuePair<, >).MakeGenericType(type.GenericTypeArguments);
				FieldInfo field = type2.GetField("key", BindingFlags.Instance | BindingFlags.NonPublic);
				FieldInfo field2 = type2.GetField("value", BindingFlags.Instance | BindingFlags.NonPublic);
				for (int j = 0; j < num2; j++)
				{
					object obj = ReadValueWithTypeFromZPackage(package, type2);
					dictionary.Add(field.GetValue(obj), field2.GetValue(obj));
				}
				return dictionary;
			}
			if (type != typeof(List<string>) && type.IsGenericType)
			{
				Type type3 = typeof(ICollection<>).MakeGenericType(type.GenericTypeArguments[0]);
				if ((object)type3 != null && type3.IsAssignableFrom(type))
				{
					int num3 = package.ReadInt();
					object obj2 = Activator.CreateInstance(type);
					MethodInfo method = type3.GetMethod("Add");
					for (int k = 0; k < num3; k++)
					{
						method.Invoke(obj2, new object[1] { ReadValueWithTypeFromZPackage(package, type.GenericTypeArguments[0]) });
					}
					return obj2;
				}
			}
			ParameterInfo parameterInfo = (ParameterInfo)FormatterServices.GetUninitializedObject(typeof(ParameterInfo));
			AccessTools.DeclaredField(typeof(ParameterInfo), "ClassImpl").SetValue(parameterInfo, type);
			List<object> source = new List<object>();
			ZRpc.Deserialize(new ParameterInfo[2] { null, parameterInfo }, package, ref source);
			return source.First();
		}
	}
	[<68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(0)]
	[PublicAPI]
	[<32b27d4b-cccc-4fc0-bc4e-1fac6f0cf550>NullableContext(1)]
	[HarmonyPatch]
	internal class VersionCheck
	{
		private static readonly HashSet<VersionCheck> versionChecks;

		private static readonly Dictionary<string, string> notProcessedNames;

		public string Name;

		[<68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(2)]
		private string displayName;

		[<68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(2)]
		private string currentVersion;

		[<68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(2)]
		private string minimumRequiredVersion;

		public bool ModRequired = true;

		[<68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(2)]
		private string ReceivedCurrentVersion;

		[<68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(2)]
		private string ReceivedMinimumRequiredVersion;

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

		[<68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(2)]
		private ConfigSync ConfigSync;

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

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

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

		private static void PatchServerSync()
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			Patches patchInfo = PatchProcessor.GetPatchInfo((MethodBase)AccessTools.DeclaredMethod(typeof(ZNet), "Awake", (Type[])null, (Type[])null));
			if (patchInfo != null && patchInfo.Postfixes.Count([<32b27d4b-cccc-4fc0-bc4e-1fac6f0cf550>NullableContext(0)] (Patch p) => p.PatchMethod.DeclaringType == typeof(ConfigSync.RegisterRPCPatch)) > 0)
			{
				return;
			}
			Harmony val = new Harmony("org.bepinex.helpers.ServerSync");
			foreach (Type item in from t in typeof(ConfigSync).GetNestedTypes(BindingFlags.NonPublic).Concat(new Type[1] { typeof(VersionCheck) })
				where t.IsClass
				select t)
			{
				val.PatchAll(item);
			}
		}

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

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

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

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

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

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

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

		private string Error([<68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(2)] ZRpc rpc = null)
		{
			return (rpc == null) ? ErrorClient() : ErrorServer(rpc);
		}

		private static VersionCheck[] GetFailedClient()
		{
			return versionChecks.Where([<32b27d4b-cccc-4fc0-bc4e-1fac6f0cf550>NullableContext(0)] (VersionCheck check) => !check.IsVersionOk()).ToArray();
		}

		private static VersionCheck[] GetFailedServer(ZRpc rpc)
		{
			return versionChecks.Where([<32b27d4b-cccc-4fc0-bc4e-1fac6f0cf550>NullableContext(0)] (VersionCheck check) => check.ModRequired && !check.ValidatedClients.Contains(rpc)).ToArray();
		}

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

		private static void DisconnectClient(ZRpc rpc)
		{
			rpc.Invoke("Error", new object[1] { 3 });
		}

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

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

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

		[HarmonyPrefix]
		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		private static void RegisterAndCheckVersion(ZNetPeer peer, ZNet __instance)
		{
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Expected O, but got Unknown
			notProcessedNames.Clear();
			IDictionary dictionary = (IDictionary)typeof(ZRpc).GetField("m_functions", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(peer.m_rpc);
			if (dictionary.Contains(StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")))
			{
				object obj = dictionary[StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")];
				Action<ZRpc, ZPackage> action = (Action<ZRpc, ZPackage>)obj.GetType().GetField("m_action", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(obj);
				peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)([<32b27d4b-cccc-4fc0-bc4e-1fac6f0cf550>NullableContext(0)] (ZRpc rpc, [<68981f5c-6a43-4b32-90d8-46e25679519d>Nullable(1)] ZPackage pkg) =>
				{
					CheckVersion(rpc, pkg, action);
				}));
			}
			else
			{
				peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)CheckVersion);
			}
			foreach (VersionCheck versionCheck in versionChecks)
			{
				versionCheck.Initialize();
				if (versionCheck.ModRequired || __instance.IsServer())
				{
					Debug.Log((object)("Sending " + versionCheck.DisplayName + " version " + versionCheck.CurrentVersion + " and minimum version " + versionCheck.MinimumRequiredVersion + " to the " + (__instance.IsServer() ? "client" : "server") + "."));
					ZPackage val = new ZPackage();
					val.Write(versionCheck.Name);
					val.Write(versionCheck.MinimumRequiredVersion);
					val.Write(versionCheck.CurrentVersion);
					peer.m_rpc.Invoke("ServerSync VersionCheck", new object[1] { val });
				}
			}
		}

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

		[HarmonyPostfix]
		[HarmonyPatch(typeof(FejdStartup), "ShowConnectError")]
		private static void ShowConnectionError(FejdStartup __instance)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			if (!__instance.m_connectionFailedPanel.activeSelf || (int)ZNet.GetConnectionStatus() != 3)
			{
				return;
			}
			bool flag = false;
			VersionCheck[] failedClient = GetFailedClient();
			if (failedClient.Length != 0)
			{
				string text = string.Join("\n", failedClient.Select([<32b27d4b-cccc-4fc0-bc4e-1fac6f0cf550>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([<32b27d4b-cccc-4fc0-bc4e-1fac6f0cf550>NullableContext(0)] (KeyValuePair<string, string> kv) => kv.Key))
			{
				if (!__instance.m_connectionFailedError.text.Contains(item.Key))
				{
					TMP_Text connectionFailedError2 = __instance.m_connectionFailedError;
					connectionFailedError2.text = connectionFailedError2.text + "\nServer expects you to have " + item.Key + " (Version: " + item.Value + ") installed.";
					flag = true;
				}
			}
			if (flag)
			{
				RectTransform component = ((Component)__instance.m_connectionFailedPanel.transform.Find("Image")).GetComponent<RectTransform>();
				Vector2 sizeDelta = component.sizeDelta;
				sizeDelta.x = 675f;
				component.sizeDelta = sizeDelta;
				__instance.m_connectionFailedError.ForceMeshUpdate(false, false);
				float num = __instance.m_connectionFailedError.renderedHeight + 105f;
				RectTransform component2 = ((Component)((Component)component).transform.Find("ButtonOk")).GetComponent<RectTransform>();
				component2.anchoredPosition = new Vector2(component2.anchoredPosition.x, component2.anchoredPosition.y - (num - component.sizeDelta.y) / 2f);
				sizeDelta = component.sizeDelta;
				sizeDelta.y = num;
				component.sizeDelta = sizeDelta;
			}
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[<3e25ca6a-8cbb-48fa-9c73-51beaf44d91c>Embedded]
	[CompilerGenerated]
	internal sealed class <3e25ca6a-8cbb-48fa-9c73-51beaf44d91c>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[<3e25ca6a-8cbb-48fa-9c73-51beaf44d91c>Embedded]
	[CompilerGenerated]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	[CompilerGenerated]
	[<3e25ca6a-8cbb-48fa-9c73-51beaf44d91c>Embedded]
	internal sealed class <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[<3e25ca6a-8cbb-48fa-9c73-51beaf44d91c>Embedded]
	[CompilerGenerated]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class <ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public <ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace YamlDotNet
{
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	internal sealed class CultureInfoAdapter : CultureInfo
	{
		private readonly IFormatProvider provider;

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

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
		public override object GetFormat(Type formatType)
		{
			return provider.GetFormat(formatType);
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	internal static class ReflectionExtensions
	{
		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		private static readonly FieldInfo RemoteStackTraceField = typeof(Exception).GetField("_remoteStackTraceString", BindingFlags.Instance | BindingFlags.NonPublic);

		[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		public static Type BaseType(this Type type)
		{
			return type.BaseType;
		}

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

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

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

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

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

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

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

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

		[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		public static PropertyInfo GetPublicProperty(this Type type, string name)
		{
			return type.GetProperty(name);
		}

		[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		public static FieldInfo GetPublicStaticField(this Type type, string name)
		{
			return type.GetField(name, BindingFlags.Static | BindingFlags.Public);
		}

		public static IEnumerable<PropertyInfo> GetProperties(this Type type, bool includeNonPublic)
		{
			BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public;
			if (includeNonPublic)
			{
				bindingFlags |= BindingFlags.NonPublic;
			}
			if (!type.IsInterface)
			{
				return type.GetProperties(bindingFlags);
			}
			return new Type[1] { type }.Concat(type.GetInterfaces()).SelectMany([<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)] (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 + "'.");
		}

		[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		public static MethodInfo GetPublicStaticMethod(this Type type, string name, params Type[] parameterTypes)
		{
			return type.GetMethod(name, BindingFlags.Static | BindingFlags.Public, null, parameterTypes, null);
		}

		[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		public static MethodInfo GetPublicInstanceMethod(this Type type, string name)
		{
			return type.GetMethod(name, BindingFlags.Instance | BindingFlags.Public);
		}

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

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

		public static Attribute[] GetAllCustomAttributes<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] TAttribute>(this PropertyInfo property)
		{
			return Attribute.GetCustomAttributes(property, typeof(TAttribute), inherit: true);
		}
	}
	internal static class PropertyInfoExtensions
	{
		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		public static object ReadValue(this PropertyInfo property, object target)
		{
			return property.GetValue(target, null);
		}
	}
	internal static class StandardRegexOptions
	{
		public const RegexOptions Compiled = RegexOptions.Compiled;
	}
}
namespace YamlDotNet.Serialization
{
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal abstract class BuilderSkeleton<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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(YamlDotNet.Serialization.Converters.GuidConverter),
					(Nothing _) => new YamlDotNet.Serialization.Converters.GuidConverter(jsonCompatible: false)
				},
				{
					typeof(SystemTypeConverter),
					(Nothing _) => new SystemTypeConverter()
				}
			};
			typeInspectorFactories = new LazyComponentRegistrationList<ITypeInspector, ITypeInspector>();
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] TClass>(Expression<Func<TClass, object>> propertyAccessor, Attribute attribute)
		{
			overrides.Add(propertyAccessor, attribute);
			return Self;
		}

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

		public TBuilder WithTypeConverter(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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory) where TTypeInspector : ITypeInspector
		{
			return WithTypeInspector(typeInspectorFactory, delegate(IRegistrationLocationSelectionSyntax<ITypeInspector> w)
			{
				w.OnTop();
			});
		}

		public TBuilder WithTypeInspector<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] TTypeInspector>() where TTypeInspector : ITypeInspector
		{
			return WithoutTypeInspector(typeof(TTypeInspector));
		}

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

		protected IEnumerable<IYamlTypeConverter> BuildTypeConverters()
		{
			return typeConverterFactories.BuildComponentList();
		}
	}
	internal delegate TComponent WrapperFactory<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] TComponentBase, TComponent>(TComponentBase wrapped) where TComponent : TComponentBase;
	internal delegate TComponent WrapperFactory<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] TArgument, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] TComponentBase, TComponent>(TComponentBase wrapped, TArgument argument) where TComponent : TComponentBase;
	[Flags]
	internal enum DefaultValuesHandling
	{
		Preserve = 0,
		OmitNull = 1,
		OmitDefaults = 2,
		OmitEmptyCollections = 4
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] T>(string input)
		{
			using StringReader input2 = new StringReader(input);
			return Deserialize<T>(input2);
		}

		public T Deserialize<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] T>(TextReader input)
		{
			return Deserialize<T>(new Parser(input));
		}

		[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		public object Deserialize(TextReader input)
		{
			return Deserialize(input, typeof(object));
		}

		[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		public object Deserialize(string input, Type type)
		{
			using StringReader input2 = new StringReader(input);
			return Deserialize(input2, type);
		}

		[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		public object Deserialize(TextReader input, Type type)
		{
			return Deserialize(new Parser(input), type);
		}

		public T Deserialize<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] T>(IParser parser)
		{
			return (T)Deserialize(parser, typeof(T));
		}

		[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		public object Deserialize(IParser parser)
		{
			return Deserialize(parser, typeof(object));
		}

		[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		public object Deserialize(IParser parser, Type type)
		{
			if (parser == null)
			{
				throw new ArgumentNullException("parser");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			YamlDotNet.Core.Events.StreamStart @event;
			bool flag = parser.TryConsume<YamlDotNet.Core.Events.StreamStart>(out @event);
			YamlDotNet.Core.Events.DocumentStart event2;
			bool flag2 = parser.TryConsume<YamlDotNet.Core.Events.DocumentStart>(out event2);
			object result = null;
			if (!parser.Accept<YamlDotNet.Core.Events.DocumentEnd>(out var _) && !parser.Accept<YamlDotNet.Core.Events.StreamEnd>(out var _))
			{
				using SerializerState serializerState = new SerializerState();
				result = valueDeserializer.DeserializeValue(parser, type, serializerState, valueDeserializer);
				serializerState.OnDeserialization();
			}
			if (flag2)
			{
				parser.Consume<YamlDotNet.Core.Events.DocumentEnd>();
			}
			if (flag)
			{
				parser.Consume<YamlDotNet.Core.Events.StreamEnd>();
			}
			return result;
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 0, 1 })]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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 var 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] TInterface, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] TConcrete>() where TConcrete : TInterface
		{
			Type typeFromHandle = typeof(TInterface);
			Type typeFromHandle2 = typeof(TConcrete);
			if (!typeFromHandle.IsAssignableFrom(typeFromHandle2))
			{
				throw new InvalidOperationException("The type '" + typeFromHandle2.Name + "' does not implement interface '" + typeFromHandle.Name + "'.");
			}
			if (typeMappings.ContainsKey(typeFromHandle))
			{
				typeMappings[typeFromHandle] = typeFromHandle2;
			}
			else
			{
				typeMappings.Add(typeFromHandle, typeFromHandle2);
			}
			return this;
		}

		public 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));
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] T>() where T : IObjectGraphVisitor<Nothing>
		{
			return preProcessingPhaseVisitors.OfType<T>().Single();
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal abstract class EventInfo
	{
		public IObjectDescriptor Source { get; }

		protected EventInfo(IObjectDescriptor source)
		{
			Source = source ?? throw new ArgumentNullException("source");
		}
	}
	internal class AliasEventInfo : EventInfo
	{
		public AnchorName Alias { get; }

		public bool NeedsExpansion { get; set; }

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		public AliasEventInfo(IObjectDescriptor source, AnchorName alias)
			: base(source)
		{
			if (alias.IsEmpty)
			{
				throw new ArgumentNullException("alias");
			}
			Alias = alias;
		}
	}
	internal class ObjectEventInfo : EventInfo
	{
		public AnchorName Anchor { get; set; }

		public TagName Tag { get; set; }

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		protected ObjectEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal sealed class ScalarEventInfo : ObjectEventInfo
	{
		public string RenderedValue { get; set; }

		public ScalarStyle Style { get; set; }

		public bool IsPlainImplicit { get; set; }

		public bool IsQuotedImplicit { get; set; }

		public ScalarEventInfo(IObjectDescriptor source)
			: base(source)
		{
			Style = source.ScalarStyle;
			RenderedValue = string.Empty;
		}
	}
	internal sealed class MappingStartEventInfo : ObjectEventInfo
	{
		public bool IsImplicit { get; set; }

		public MappingStyle Style { get; set; }

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		public MappingStartEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class MappingEndEventInfo : EventInfo
	{
		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		public MappingEndEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class SequenceStartEventInfo : ObjectEventInfo
	{
		public bool IsImplicit { get; set; }

		public SequenceStyle Style { get; set; }

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		public SequenceStartEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class SequenceEndEventInfo : EventInfo
	{
		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		public SequenceEndEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal interface IAliasProvider
	{
		AnchorName GetAlias(object target);
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal interface IDeserializer
	{
		T Deserialize<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] T>(string input);

		T Deserialize<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] T>(TextReader input);

		[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		object Deserialize(TextReader input);

		[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		object Deserialize(string input, Type type);

		[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		object Deserialize(TextReader input, Type type);

		T Deserialize<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] T>(IParser parser);

		[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		object Deserialize(IParser parser);

		[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		object Deserialize(IParser parser, Type type);
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	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);
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal interface INamingConvention
	{
		string Apply(string value);
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal interface INodeDeserializer
	{
		bool Deserialize(IParser reader, Type expectedType, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] out object value);
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal interface INodeTypeResolver
	{
		bool Resolve([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] NodeEvent nodeEvent, ref Type currentType);
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal interface IObjectAccessor
	{
		void Set(string name, object target, object value);

		[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		object Read(string name, object target);
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal interface IObjectDescriptor
	{
		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		object Value
		{
			[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
			get;
		}

		Type Type { get; }

		Type StaticType { get; }

		ScalarStyle ScalarStyle { get; }
	}
	internal static class ObjectDescriptorExtensions
	{
		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		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.");
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal interface IObjectFactory
	{
		object Create(Type type);

		[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		object CreatePrimitive(Type type);

		bool GetDictionary(IObjectDescriptor descriptor, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] out IDictionary dictionary, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 2, 1 })] out Type[] genericArguments);

		Type GetValueType(Type type);
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal interface IObjectGraphTraversalStrategy
	{
		void Traverse<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] TContext>(IObjectDescriptor graph, IObjectGraphVisitor<TContext> visitor, TContext context);
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal interface IObjectGraphVisitor<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] 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);
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal interface IPropertyDescriptor
	{
		string Name { get; }

		bool CanWrite { get; }

		Type Type { get; }

		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		Type TypeOverride
		{
			[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
			get;
			[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
			set;
		}

		int Order { get; set; }

		ScalarStyle ScalarStyle { get; set; }

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)]
		[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		T GetCustomAttribute<T>() where T : Attribute;

		IObjectDescriptor Read(object target);

		void Write(object target, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object value);
	}
	internal interface IRegistrationLocationSelectionSyntax<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] TBaseRegistrationType>
	{
		void InsteadOf<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;

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

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

		void OnTop();

		void OnBottom();
	}
	internal interface ITrackingRegistrationLocationSelectionSyntax<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] TBaseRegistrationType>
	{
		void InsteadOf<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal interface ISerializer
	{
		void Serialize(TextWriter writer, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object graph);

		string Serialize([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object graph);

		void Serialize(TextWriter writer, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object graph, Type type);

		void Serialize(IEmitter emitter, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object graph);

		void Serialize(IEmitter emitter, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object graph, Type type);
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal interface ITypeInspector
	{
		IEnumerable<IPropertyDescriptor> GetProperties(Type type, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object container);

		IPropertyDescriptor GetProperty(Type type, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object container, string name, [MaybeNullWhen(true)] bool ignoreUnmatched);
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal interface ITypeResolver
	{
		Type Resolve(Type staticType, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object actualValue);
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal interface IValueDeserializer
	{
		[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		object DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer);
	}
	internal interface IValuePromise
	{
		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 1, 2 })]
		event Action<object> ValueAvailable;
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
	internal interface IValueSerializer
	{
		void SerializeValue([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(1)] IEmitter emitter, object value, Type type);
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal interface IYamlConvertible
	{
		void Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer);

		void Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer);
	}
	[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
	internal delegate object ObjectDeserializer(Type type);
	internal delegate void ObjectSerializer(object value, Type type = null);
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[Obsolete("Please use IYamlConvertible instead")]
	internal interface IYamlSerializable
	{
		void ReadYaml(IParser parser);

		void WriteYaml(IEmitter emitter);
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal interface IYamlTypeConverter
	{
		bool Accepts(Type type);

		[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		object ReadYaml(IParser parser, Type type);

		void WriteYaml(IEmitter emitter, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object value, Type type);
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	internal sealed class LazyComponentRegistrationList<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] TArgument, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] TComponent> : IEnumerable<Func<TArgument, TComponent>>, IEnumerable
	{
		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
		public sealed class LazyComponentRegistration
		{
			public readonly Type ComponentType;

			public readonly Func<TArgument, TComponent> Factory;

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

		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
		public sealed class TrackingLazyComponentRegistration
		{
			public readonly Type ComponentType;

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

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

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)]
		private class RegistrationLocationSelector : IRegistrationLocationSelectionSyntax<TComponent>
		{
			[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(1)]
			private readonly LazyComponentRegistrationList<TArgument, TComponent> registrations;

			[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 1, 0, 0 })]
			private readonly LazyComponentRegistration newRegistration;

			[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
			public RegistrationLocationSelector(LazyComponentRegistrationList<TArgument, TComponent> registrations, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 1, 0, 0 })] 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);
			}
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)]
		private class TrackingRegistrationLocationSelector : ITrackingRegistrationLocationSelectionSyntax<TComponent>
		{
			[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(1)]
			private readonly LazyComponentRegistrationList<TArgument, TComponent> registrations;

			[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 1, 0, 0 })]
			private readonly TrackingLazyComponentRegistration newRegistration;

			[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
			public TrackingRegistrationLocationSelector(LazyComponentRegistrationList<TArgument, TComponent> registrations, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 1, 0, 0 })] 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, [<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)] (TArgument arg) => newRegistration.Factory(innerComponentFactory(arg), arg));
			}
		}

		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 1, 1, 0, 0 })]
		private readonly List<LazyComponentRegistration> entries = new List<LazyComponentRegistration>();

		public int Count => entries.Count;

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

		public 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([<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)] (LazyComponentRegistration e) => e.Factory).GetEnumerator();
		}

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

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

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

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
		private int EnsureRegistrationExists<TRegistrationType>()
		{
			int num = IndexOfRegistration(typeof(TRegistrationType));
			if (num == -1)
			{
				throw new InvalidOperationException("A component of type '" + typeof(TRegistrationType).FullName + "' has not been registered.");
			}
			return num;
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal static class LazyComponentRegistrationListExtensions
	{
		public static TComponent BuildComponentChain<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] TComponent>(this LazyComponentRegistrationList<TComponent, TComponent> registrations, TComponent innerComponent)
		{
			return registrations.InReverseOrder.Aggregate(innerComponent, [<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)] (TComponent inner, Func<TComponent, TComponent> factory) => factory(inner));
		}

		public static TComponent BuildComponentChain<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] TArgument, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] TComponent>(this LazyComponentRegistrationList<TArgument, TComponent> registrations, TComponent innerComponent, Func<TComponent, TArgument> argumentBuilder)
		{
			return registrations.InReverseOrder.Aggregate(innerComponent, [<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)] (TComponent inner, Func<TArgument, TComponent> factory) => factory(argumentBuilder(inner)));
		}

		public static List<TComponent> BuildComponentList<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] TComponent>(this LazyComponentRegistrationList<Nothing, TComponent> registrations)
		{
			return registrations.Select([<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)] (Func<Nothing, TComponent> factory) => factory(default(Nothing))).ToList();
		}

		public static List<TComponent> BuildComponentList<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] TArgument, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] TComponent>(this LazyComponentRegistrationList<TArgument, TComponent> registrations, TArgument argument)
		{
			return registrations.Select([<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)] (Func<TArgument, TComponent> factory) => factory(argument)).ToList();
		}
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	internal struct Nothing
	{
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	internal sealed class ObjectDescriptor : IObjectDescriptor
	{
		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		[field: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		public object Value
		{
			[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
			get;
			[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
			private set;
		}

		public Type Type { get; private set; }

		public Type StaticType { get; private set; }

		public ScalarStyle ScalarStyle { get; private set; }

		public ObjectDescriptor([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object value, Type type, Type staticType)
			: this(value, type, staticType, ScalarStyle.Any)
		{
		}

		public ObjectDescriptor([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object value, Type type, Type staticType, ScalarStyle scalarStyle)
		{
			Value = value;
			Type = type ?? throw new ArgumentNullException("type");
			StaticType = staticType ?? throw new ArgumentNullException("staticType");
			ScalarStyle = scalarStyle;
		}
	}
	internal delegate IObjectGraphTraversalStrategy ObjectGraphTraversalStrategyFactory(ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion);
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal sealed class PropertyDescriptor : IPropertyDescriptor
	{
		private readonly IPropertyDescriptor baseDescriptor;

		public string Name { get; set; }

		public Type Type => baseDescriptor.Type;

		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		public Type TypeOverride
		{
			[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
			get
			{
				return baseDescriptor.TypeOverride;
			}
			[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
			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, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object value)
		{
			baseDescriptor.Write(target, value);
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)]
		[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		public T GetCustomAttribute<T>() where T : Attribute
		{
			return baseDescriptor.GetCustomAttribute<T>();
		}

		public IObjectDescriptor Read(object target)
		{
			return baseDescriptor.Read(target);
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	internal sealed class Serializer : ISerializer
	{
		private readonly IValueSerializer valueSerializer;

		private readonly EmitterSettings emitterSettings;

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

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

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

		public void Serialize(TextWriter writer, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object graph)
		{
			Serialize(new Emitter(writer, emitterSettings), graph);
		}

		public string Serialize([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object graph)
		{
			using StringWriter stringWriter = new StringWriter();
			Serialize(stringWriter, graph);
			return stringWriter.ToString();
		}

		public void Serialize(TextWriter writer, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object graph, Type type)
		{
			Serialize(new Emitter(writer, emitterSettings), graph, type);
		}

		public void Serialize(IEmitter emitter, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object graph)
		{
			if (emitter == null)
			{
				throw new ArgumentNullException("emitter");
			}
			EmitDocument(emitter, graph, null);
		}

		public void Serialize(IEmitter emitter, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object graph, Type type)
		{
			if (emitter == null)
			{
				throw new ArgumentNullException("emitter");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			EmitDocument(emitter, graph, type);
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
		private void EmitDocument([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(1)] IEmitter emitter, object graph, Type type)
		{
			emitter.Emit(new YamlDotNet.Core.Events.StreamStart());
			emitter.Emit(new YamlDotNet.Core.Events.DocumentStart());
			valueSerializer.SerializeValue(emitter, graph, type);
			emitter.Emit(new YamlDotNet.Core.Events.DocumentEnd(isImplicit: true));
			emitter.Emit(new YamlDotNet.Core.Events.StreamEnd());
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 0, 1 })]
	internal sealed class SerializerBuilder : BuilderSkeleton<SerializerBuilder>
	{
		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
		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;
			}

			[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
			public void SerializeValue([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(1)] 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(new EmittingObjectGraphVisitor(eventEmitter), [<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)] (IObjectGraphVisitor<IEmitter> inner) => new EmissionPhaseObjectGraphVisitorArgs(inner, eventEmitter, preProcessingPhaseObjectGraphVisitors, typeConverters, NestedObjectSerializer));
				traversalStrategy.Traverse(graph, visitor, emitter);
				[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
				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 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory) where TEventEmitter : IEventEmitter
		{
			return WithEventEmitter(eventEmitterFactory, delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> w)
			{
				w.OnTop();
			});
		}

		public SerializerBuilder WithEventEmitter<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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([<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)] ([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(1)] IEventEmitter inner) => new TypeAssigningEventEmitter(inner, requireTagWhenStaticAndActualTypesAreDifferent: true, tagMappings, quoteNecessaryStrings, quoteYaml1_1Strings), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
			{
				loc.InsteadOf<TypeAssigningEventEmitter>();
			});
			return WithTypeInspector([<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)] ([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(1)] ITypeInspector inner) => new ReadableAndWritablePropertiesTypeInspector(inner), delegate(IRegistrationLocationSelectionSyntax<ITypeInspector> loc)
			{
				loc.OnBottom();
			});
		}

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

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

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

		public SerializerBuilder JsonCompatible()
		{
			emitterSettings = emitterSettings.WithMaxSimpleKeyLength(int.MaxValue).WithoutAnchorName();
			return WithTypeConverter(new YamlDotNet.Serialization.Converters.GuidConverter(jsonCompatible: true), delegate(IRegistrationLocationSelectionSyntax<IYamlTypeConverter> w)
			{
				w.InsteadOf<YamlDotNet.Serialization.Converters.GuidConverter>();
			}).WithTypeConverter(new YamlDotNet.Serialization.Converters.DateTimeConverter(DateTimeKind.Utc, null, true)).WithEventEmitter([<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)] ([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(1)] 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			return WithPreProcessingPhaseObjectGraphVisitor(objectGraphVisitor, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>> w)
			{
				w.OnTop();
			});
		}

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] TObjectGraphVisitor>(Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			return WithEmissionPhaseObjectGraphVisitor(objectGraphVisitorFactory, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>> w)
			{
				w.OnTop();
			});
		}

		public SerializerBuilder WithEmissionPhaseObjectGraphVisitor<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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);
		}
	}
	internal class Settings
	{
		public bool AllowPrivateConstructors { get; set; }
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	internal abstract class StaticBuilderSkeleton<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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(YamlDotNet.Serialization.Converters.GuidConverter),
				(Nothing _) => new YamlDotNet.Serialization.Converters.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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory) where TTypeInspector : ITypeInspector
		{
			return WithTypeInspector(typeInspectorFactory, delegate(IRegistrationLocationSelectionSyntax<ITypeInspector> w)
			{
				w.OnTop();
			});
		}

		public TBuilder WithTypeInspector<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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();
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal abstract class StaticContext
	{
		public virtual StaticObjectFactory GetFactory()
		{
			throw new NotImplementedException();
		}

		public virtual ITypeInspector GetTypeInspector()
		{
			throw new NotImplementedException();
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 0, 1 })]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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 var value))
			{
				throw new ArgumentException($"Type already has a registered type '{value.FullName}' for tag '{tag}'", "tag");
			}
			tagMappings.Add(tag, type);
			return this;
		}

		public StaticDeserializerBuilder WithTypeMapping<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] TInterface, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] TConcrete>() where TConcrete : TInterface
		{
			Type typeFromHandle = typeof(TInterface);
			Type typeFromHandle2 = typeof(TConcrete);
			if (!typeFromHandle.IsAssignableFrom(typeFromHandle2))
			{
				throw new InvalidOperationException("The type '" + typeFromHandle2.Name + "' does not implement interface '" + typeFromHandle.Name + "'.");
			}
			if (typeMappings.ContainsKey(typeFromHandle))
			{
				typeMappings[typeFromHandle] = typeFromHandle2;
			}
			else
			{
				typeMappings.Add(typeFromHandle, typeFromHandle2);
			}
			return this;
		}

		public StaticDeserializerBuilder WithoutTagMapping(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));
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 0, 1 })]
	internal sealed class StaticSerializerBuilder : StaticBuilderSkeleton<StaticSerializerBuilder>
	{
		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
		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;
			}

			[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
			public void SerializeValue([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(1)] 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(new EmittingObjectGraphVisitor(eventEmitter), [<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)] (IObjectGraphVisitor<IEmitter> inner) => new EmissionPhaseObjectGraphVisitorArgs(inner, eventEmitter, preProcessingPhaseObjectGraphVisitors, typeConverters, NestedObjectSerializer));
				traversalStrategy.Traverse(graph, visitor, emitter);
				[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
				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 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory) where TEventEmitter : IEventEmitter
		{
			return WithEventEmitter(eventEmitterFactory, delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> w)
			{
				w.OnTop();
			});
		}

		public StaticSerializerBuilder WithEventEmitter<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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([<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)] ([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(1)] IEventEmitter inner) => new TypeAssigningEventEmitter(inner, requireTagWhenStaticAndActualTypesAreDifferent: true, tagMappings, quoteNecessaryStrings), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
			{
				loc.InsteadOf<TypeAssigningEventEmitter>();
			});
			return WithTypeInspector([<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)] ([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(1)] 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 YamlDotNet.Serialization.Converters.GuidConverter(jsonCompatible: true), delegate(IRegistrationLocationSelectionSyntax<IYamlTypeConverter> w)
			{
				w.InsteadOf<YamlDotNet.Serialization.Converters.GuidConverter>();
			}).WithEventEmitter([<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)] ([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(1)] 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			return WithPreProcessingPhaseObjectGraphVisitor(objectGraphVisitor, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>> w)
			{
				w.OnTop();
			});
		}

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] TObjectGraphVisitor>(Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			return WithEmissionPhaseObjectGraphVisitor(objectGraphVisitorFactory, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>> w)
			{
				w.OnTop();
			});
		}

		public StaticSerializerBuilder WithEmissionPhaseObjectGraphVisitor<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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);
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	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);
			}
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	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);
		}

		[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		internal Type GetMapping(string tag)
		{
			if (!mappings.TryGetValue(tag, out var value))
			{
				return null;
			}
			return value;
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal sealed class YamlAttributeOverrides
	{
		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
		private struct AttributeKey
		{
			public readonly Type AttributeType;

			public readonly string PropertyName;

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

			[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
			public override bool Equals(object obj)
			{
				if (obj is AttributeKey attributeKey && AttributeType.Equals(attributeKey.AttributeType))
				{
					return PropertyName.Equals(attributeKey.PropertyName);
				}
				return false;
			}

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

		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
		private sealed class AttributeMapping
		{
			public readonly Type RegisteredType;

			public readonly Attribute Attribute;

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

			[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
			public override bool Equals(object obj)
			{
				if (obj is AttributeMapping attributeMapping && RegisteredType.Equals(attributeMapping.RegisteredType))
				{
					return Attribute.Equals(attributeMapping.Attribute);
				}
				return false;
			}

			public override int GetHashCode()
			{
				return 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(RegisteredType))
				{
					return num;
				}
				return 0;
			}
		}

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

		[return: MaybeNull]
		public T GetAttribute<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] T>(Type type, string member) where T : Attribute
		{
			if (overrides.TryGetValue(new AttributeKey(typeof(T), member), out var value))
			{
				int num = 0;
				AttributeMapping attributeMapping = null;
				foreach (AttributeMapping item in value)
				{
					int num2 = item.Matches(type);
					if (num2 > num)
					{
						num = num2;
						attributeMapping = item;
					}
				}
				if (num > 0)
				{
					return (T)attributeMapping.Attribute;
				}
			}
			return null;
		}

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

		public 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] TClass>(Expression<Func<TClass, object>> propertyAccessor, Attribute attribute)
		{
			PropertyInfo propertyInfo = propertyAccessor.AsProperty();
			Add(typeof(TClass), propertyInfo.Name, attribute);
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	internal sealed class YamlAttributeOverridesInspector : TypeInspectorSkeleton
	{
		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
		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;

			[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
			public Type TypeOverride
			{
				[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
				get
				{
					return baseDescriptor.TypeOverride;
				}
				[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
				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, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object value)
			{
				baseDescriptor.Write(target, value);
			}

			[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)]
			[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
			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, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object container)
		{
			IEnumerable<IPropertyDescriptor> enumerable = innerTypeDescriptor.GetProperties(type, container);
			if (overrides != null)
			{
				enumerable = enumerable.Select((Func<IPropertyDescriptor, IPropertyDescriptor>)([<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)] (IPropertyDescriptor p) => new OverridePropertyDescriptor(p, overrides, type)));
			}
			return enumerable;
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal sealed class YamlAttributesTypeInspector : TypeInspectorSkeleton
	{
		private readonly ITypeInspector innerTypeDescriptor;

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

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object container)
		{
			return from p in (from p in innerTypeDescriptor.GetProperties(type, container)
					where p.GetCustomAttribute<YamlIgnoreAttribute>() == null
					select p).Select((Func<IPropertyDescriptor, IPropertyDescriptor>)([<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)] (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;
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	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).ToString();
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
	internal sealed class YamlIgnoreAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	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;
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		public YamlMemberAttribute(Type serializeAs)
			: this()
		{
			SerializeAs = serializeAs ?? throw new ArgumentNullException("serializeAs");
		}
	}
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	internal sealed class YamlSerializableAttribute : Attribute
	{
	}
	internal sealed class YamlStaticContextAttribute : Attribute
	{
	}
}
namespace YamlDotNet.Serialization.ValueDeserializers
{
	internal sealed class AliasValueDeserializer : IValueDeserializer
	{
		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 0, 1 })]
		private sealed class AliasState : Dictionary<AnchorName, ValuePromise>, IPostDeserializationCallback
		{
			public void OnDeserialization()
			{
				foreach (ValuePromise value in base.Values)
				{
					if (!value.HasValue)
					{
						YamlDotNet.Core.Events.AnchorAlias alias = value.Alias;
						Mark start = alias.Start;
						Mark end = alias.End;
						throw new AnchorNotFoundException(in start, in end, $"Anchor '{alias.Value}' not found");
					}
				}
			}
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
		private sealed class ValuePromise : IValuePromise
		{
			private object value;

			public readonly YamlDotNet.Core.Events.AnchorAlias Alias;

			public bool HasValue { get; private set; }

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

			public event Action<object> ValueAvailable;

			[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
			public ValuePromise(YamlDotNet.Core.Events.AnchorAlias alias)
			{
				Alias = alias;
			}

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

		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(1)]
		private readonly IValueDeserializer innerDeserializer;

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		public AliasValueDeserializer(IValueDeserializer innerDeserializer)
		{
			this.innerDeserializer = innerDeserializer ?? throw new ArgumentNullException("innerDeserializer");
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		public object DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
		{
			if (parser.TryConsume<YamlDotNet.Core.Events.AnchorAlias>(out var @event))
			{
				if (!state.Get<AliasState>().TryGetValue(@event.Value, out var value))
				{
					Mark start = @event.Start;
					Mark end = @event.End;
					throw new AnchorNotFoundException(in start, in end, $"Alias ${@event.Value} cannot precede anchor declaration");
				}
				if (!value.HasValue)
				{
					return value;
				}
				return value.Value;
			}
			AnchorName anchorName = AnchorName.Empty;
			if (parser.Accept<NodeEvent>(out var event2) && !event2.Anchor.IsEmpty)
			{
				anchorName = event2.Anchor;
				AliasState aliasState = state.Get<AliasState>();
				if (!aliasState.ContainsKey(anchorName))
				{
					aliasState[anchorName] = new ValuePromise(new YamlDotNet.Core.Events.AnchorAlias(anchorName));
				}
			}
			object obj = innerDeserializer.DeserializeValue(parser, expectedType, state, nestedObjectDeserializer);
			if (!anchorName.IsEmpty)
			{
				AliasState aliasState2 = state.Get<AliasState>();
				if (!aliasState2.TryGetValue(anchorName, out var value2))
				{
					aliasState2.Add(anchorName, new ValuePromise(obj));
				}
				else if (!value2.HasValue)
				{
					value2.Value = obj;
				}
				else
				{
					aliasState2[anchorName] = new ValuePromise(obj);
				}
			}
			return obj;
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	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");
		}

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

		private Type GetTypeFromEvent([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] NodeEvent nodeEvent, Type currentType)
		{
			using (IEnumerator<INodeTypeResolver> enumerator = typeResolvers.GetEnumerator())
			{
				while (enumerator.MoveNext() && !enumerator.Current.Resolve(nodeEvent, ref currentType))
				{
				}
			}
			return currentType;
		}
	}
}
namespace YamlDotNet.Serialization.Utilities
{
	internal interface IPostDeserializationCallback
	{
		void OnDeserialization();
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
	internal interface ITypeConverter
	{
		object ChangeType(object value, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(1)] Type expectedType);
	}
	internal class NullTypeConverter : ITypeConverter
	{
		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
		public object ChangeType(object value, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(1)] Type expectedType)
		{
			return value;
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	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 var 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)][<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] out string anchor)
		{
			return anchorsByObject.TryGetValue(@object, out anchor);
		}
	}
	internal class ReflectionTypeConverter : ITypeConverter
	{
		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
		public object ChangeType(object value, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(1)] Type expectedType)
		{
			return TypeConverter.ChangeType(value, expectedType);
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	internal static class ReflectionUtility
	{
		[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		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];
			}
		}
	}
	internal sealed class SerializerState : IDisposable
	{
		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(1)]
		private readonly IDictionary<Type, object> items = new Dictionary<Type, object>();

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		public T Get<T>() where T : class, new()
		{
			if (!items.TryGetValue(typeof(T), out var value))
			{
				value = new T();
				items.Add(typeof(T), value);
			}
			return (T)value;
		}

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

		public void Dispose()
		{
			foreach (IDisposable item in items.Values.OfType<IDisposable>())
			{
				item.Dispose();
			}
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal static class StringExtensions
	{
		private static string ToCamelOrPascalCase(string str, Func<char, char> firstLetterTransform)
		{
			string text = Regex.Replace(str, "([_\\-])(?<char>[a-z])", [<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)] (Match match) => match.Groups["char"].Value.ToUpperInvariant(), RegexOptions.IgnoreCase);
			return firstLetterTransform(text[0]) + text.Substring(1);
		}

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

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

		public static string FromCamelCase(this string str, string separator)
		{
			str = char.ToLower(str[0]) + str.Substring(1);
			str = Regex.Replace(str.ToCamelCase(), "(?<char>[A-Z])", [<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)] (Match match) => separator + match.Groups["char"].Value.ToLowerInvariant());
			return str;
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	internal static class TypeConverter
	{
		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
		[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(1)]
		public static T ChangeType<T>(object value)
		{
			return (T)ChangeType(value, typeof(T));
		}

		public static T ChangeType<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] T>([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object value, IFormatProvider provider)
		{
			return (T)ChangeType(value, typeof(T), provider);
		}

		public static T ChangeType<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] T>([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object value, CultureInfo culture)
		{
			return (T)ChangeType(value, typeof(T), culture);
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
		public static object ChangeType(object value, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(1)] Type destinationType)
		{
			return ChangeType(value, destinationType, CultureInfo.InvariantCulture);
		}

		[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		public static object ChangeType([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object value, Type destinationType, IFormatProvider provider)
		{
			return ChangeType(value, destinationType, new CultureInfoAdapter(CultureInfo.CurrentCulture, provider));
		}

		[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		public static object ChangeType([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] 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);
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)]
		public static void RegisterTypeConverter<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] TConvertible, TConverter>() where TConverter : System.ComponentModel.TypeConverter
		{
			if (!TypeDescriptor.GetAttributes(typeof(TConvertible)).OfType<TypeConverterAttribute>().Any([<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)] (TypeConverterAttribute a) => a.ConverterTypeName == typeof(TConverter).AssemblyQualifiedName))
			{
				TypeDescriptor.AddAttributes(typeof(TConvertible), new TypeConverterAttribute(typeof(TConverter)));
			}
		}
	}
}
namespace YamlDotNet.Serialization.TypeResolvers
{
	internal sealed class DynamicTypeResolver : ITypeResolver
	{
		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		public Type Resolve(Type staticType, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object actualValue)
		{
			if (actualValue == null)
			{
				return staticType;
			}
			return actualValue.GetType();
		}
	}
	internal sealed class StaticTypeResolver : ITypeResolver
	{
		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		public Type Resolve(Type staticType, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object actualValue)
		{
			return staticType;
		}
	}
}
namespace YamlDotNet.Serialization.TypeInspectors
{
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	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, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object container)
		{
			return cache.GetOrAdd(type, (Type t) => innerTypeDescriptor.GetProperties(t, container).ToList());
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	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, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object container)
		{
			return typeInspectors.SelectMany([<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)] (ITypeInspector i) => i.GetProperties(type, container));
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	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, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object container)
		{
			return innerTypeDescriptor.GetProperties(type, container).Select([<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)] (IPropertyDescriptor p) =>
			{
				YamlMemberAttribute customAttribute = p.GetCustomAttribute<YamlMemberAttribute>();
				return (customAttribute != null && !customAttribute.ApplyNamingConventions) ? p : new PropertyDescriptor(p)
				{
					Name = namingConvention.Apply(p.Name)
				};
			});
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	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, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object container)
		{
			return from p in innerTypeDescriptor.GetProperties(type, container)
				where p.CanWrite
				select p;
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	internal sealed class ReadableFieldsTypeInspector : TypeInspectorSkeleton
	{
		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
		private sealed class ReflectionFieldDescriptor : IPropertyDescriptor
		{
			private readonly FieldInfo fieldInfo;

			private readonly ITypeResolver typeResolver;

			public string Name => fieldInfo.Name;

			public Type Type => fieldInfo.FieldType;

			[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
			[field: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
			public Type TypeOverride
			{
				[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
				get;
				[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
				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, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object value)
			{
				fieldInfo.SetValue(target, value);
			}

			[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)]
			[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
			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, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object container)
		{
			return type.GetPublicFields().Select((Func<FieldInfo, IPropertyDescriptor>)([<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)] (FieldInfo p) => new ReflectionFieldDescriptor(p, typeResolver)));
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal sealed class ReadablePropertiesTypeInspector : TypeInspectorSkeleton
	{
		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
		private sealed class ReflectionPropertyDescriptor : IPropertyDescriptor
		{
			private readonly PropertyInfo propertyInfo;

			private readonly ITypeResolver typeResolver;

			public string Name => propertyInfo.Name;

			public Type Type => propertyInfo.PropertyType;

			[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
			[field: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
			public Type TypeOverride
			{
				[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
				get;
				[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
				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, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object value)
			{
				propertyInfo.SetValue(target, value, null);
			}

			[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)]
			[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
			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, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object container)
		{
			return type.GetProperties(includeNonPublicProperties).Where(IsValidProperty).Select((Func<PropertyInfo, IPropertyDescriptor>)([<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)] (PropertyInfo p) => new ReflectionPropertyDescriptor(p, typeResolver)));
		}
	}
	internal abstract class TypeInspectorSkeleton : ITypeInspector
	{
		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		public abstract IEnumerable<IPropertyDescriptor> GetProperties(Type type, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object container);

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		public IPropertyDescriptor GetProperty(Type type, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] 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;
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	internal sealed class WritablePropertiesTypeInspector : TypeInspectorSkeleton
	{
		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
		private sealed class ReflectionPropertyDescriptor : IPropertyDescriptor
		{
			private readonly PropertyInfo propertyInfo;

			private readonly ITypeResolver typeResolver;

			public string Name => propertyInfo.Name;

			public Type Type => propertyInfo.PropertyType;

			[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
			[field: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
			public Type TypeOverride
			{
				[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
				get;
				[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
				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, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object value)
			{
				propertyInfo.SetValue(target, value, null);
			}

			[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)]
			[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
			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, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object container)
		{
			return type.GetProperties(includeNonPublicProperties).Where(IsValidProperty).Select((Func<PropertyInfo, IPropertyDescriptor>)([<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)] (PropertyInfo p) => new ReflectionPropertyDescriptor(p, typeResolver)))
				.ToArray();
		}
	}
}
namespace YamlDotNet.Serialization.Schemas
{
	internal sealed class FailsafeSchema
	{
		public static class Tags
		{
			public static readonly TagName Map = new TagName("tag:yaml.org,2002:map");

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

			public static readonly TagName Str = new TagName("tag:yaml.org,2002:str");
		}
	}
	internal sealed class JsonSchema
	{
		public static class Tags
		{
			public static readonly TagName Null = new TagName("tag:yaml.org,2002:null");

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

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

			public static readonly TagName Float = new TagName("tag:yaml.org,2002:float");
		}
	}
	internal sealed class CoreSchema
	{
		public static class Tags
		{
		}
	}
	internal sealed class DefaultSchema
	{
		public static class Tags
		{
			public static readonly TagName Timestamp = new TagName("tag:yaml.org,2002:timestamp");
		}
	}
}
namespace YamlDotNet.Serialization.ObjectGraphVisitors
{
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	internal sealed class AnchorAssigner : PreProcessingPhaseObjectGraphVisitorSkeleton, IAliasProvider
	{
		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)]
		private class AnchorAssignment
		{
			public AnchorName Anchor;
		}

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

		private uint nextId;

		public AnchorAssigner(IEnumerable<IYamlTypeConverter> typeConverters)
			: base(typeConverters)
		{
		}

		protected override bool Enter(IObjectDescriptor value)
		{
			if (value.Value != null && assignments.TryGetValue(value.Value, out var 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 var value))
			{
				return value.Anchor;
			}
			return AnchorName.Empty;
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	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);
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	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);
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal sealed class CommentsObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		public CommentsObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor)
			: base(nextVisitor)
		{
		}

		public override bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context)
		{
			YamlMemberAttribute customAttribute = key.GetCustomAttribute<YamlMemberAttribute>();
			if (customAttribute != null && customAttribute.Description != null)
			{
				context.Emit(new YamlDotNet.Core.Events.Comment(customAttribute.Description, isInline: false));
			}
			return base.EnterMapping(key, value, context);
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	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([<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)] (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);
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	internal sealed class DefaultExclusiveObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		public DefaultExclusiveObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor)
			: base(nextVisitor)
		{
		}

		[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		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;
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	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;
		}

		[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		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) != 0 && value.Value == null)
			{
				return false;
			}
			if ((defaultValuesHandling & DefaultValuesHandling.OmitEmptyCollections) != 0 && value.Value is IEnumerable enumerable)
			{
				IEnumerator enumerator = enumerable.GetEnumerator();
				bool flag = enumerator.MoveNext();
				if (enumerator is IDisposable disposable)
				{
					disposable.Dispose();
				}
				if (!flag)
				{
					return false;
				}
			}
			if ((defaultValuesHandling & DefaultValuesHandling.OmitDefaults) != 0)
			{
				object objB = key.GetCustomAttribute<DefaultValueAttribute>()?.Value ?? GetDefault(key.Type);
				if (object.Equals(value.Value, objB))
				{
					return false;
				}
			}
			return base.EnterMapping(key, value, context);
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	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);
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	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([<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)] (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);
	}
}
namespace YamlDotNet.Serialization.ObjectGraphTraversalStrategies
{
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	internal class FullObjectGraphTraversalStrategy : IObjectGraphTraversalStrategy
	{
		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
		protected struct ObjectPathSegment
		{
			public readonly object Name;

			public readonly IObjectDescriptor Value;

			public ObjectPathSegment(object name, IObjectDescriptor value)
			{
				Name = name;
				Value = value;
			}
		}

		private readonly int maxRecursion;

		private readonly ITypeInspector typeDescriptor;

		private readonly ITypeResolver typeResolver;

		private readonly INamingConvention namingConvention;

		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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] TContext>(IObjectDescriptor graph, IObjectGraphVisitor<TContext> visitor, TContext context)
		{
			Traverse("<root>", graph, visitor, context, new Stack<ObjectPathSegment>(maxRecursion));
		}

		protected virtual void Traverse<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] 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([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object value, Type staticType)
		{
			return new ObjectDescriptor(value, typeResolver.Resolve(staticType, value), staticType);
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] TContext>(IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path)
		{
			if (!value.Type.HasDefaultConstructor(settings.AllowPrivateConstructors) && !converters.Any([<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)] (IYamlTypeConverter c) => c.Accepts(value.Type)))
			{
				throw new InvalidOperationException($"Type '{value.Type}' cannot be deserialized because it does not have a default constructor or a type converter.");
			}
			base.TraverseProperties(value, visitor, context, path);
		}
	}
}
namespace YamlDotNet.Serialization.ObjectFactories
{
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	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 var value))
					{
						type = value.MakeGenericType(type.GetGenericArguments());
					}
				}
				else if (DefaultNonGenericInterfaceImplementations.TryGetValue(type, out value2))
				{
					type = value2;
				}
			}
			try
			{
				return Activator.CreateInstance(type, settings.AllowPrivateConstructors);
			}
			catch (Exception innerException)
			{
				throw new InvalidOperationException("Failed to create an instance of type '" + type.FullName + "'.", innerException);
			}
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	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);
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	internal abstract class ObjectFactoryBase : IObjectFactory
	{
		public abstract object Create(Type type);

		[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		public virtual object CreatePrimitive(Type type)
		{
			if (!type.IsValueType())
			{
				return null;
			}
			return Activator.CreateInstance(type);
		}

		public virtual bool GetDictionary(IObjectDescriptor descriptor, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] out IDictionary dictionary, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 2, 1 })] 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];
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	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);

		[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		public virtual object CreatePrimitive(Type type)
		{
			return Type.GetTypeCode(type) switch
			{
				TypeCode.Boolean => false, 
				TypeCode.Byte => (byte)0, 
				TypeCode.Int16 => (short)0, 
				TypeCode.Int32 => 0, 
				TypeCode.Int64 => 0L, 
				TypeCode.SByte => (sbyte)0, 
				TypeCode.UInt16 => (ushort)0, 
				TypeCode.UInt32 => 0u, 
				TypeCode.UInt64 => 0uL, 
				TypeCode.Single => 0f, 
				TypeCode.Double => 0.0, 
				TypeCode.Decimal => 0m, 
				TypeCode.Char => '\0', 
				TypeCode.DateTime => default(DateTime), 
				_ => null, 
			};
		}

		public bool GetDictionary(IObjectDescriptor descriptor, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] out IDictionary dictionary, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 2, 1 })] out Type[] genericArguments)
		{
			dictionary = null;
			genericArguments = null;
			return false;
		}
	}
}
namespace YamlDotNet.Serialization.NodeTypeResolvers
{
	internal sealed class DefaultContainersNodeTypeResolver : INodeTypeResolver
	{
		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		bool INodeTypeResolver.Resolve([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] 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;
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	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([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] NodeEvent nodeEvent, ref Type currentType)
		{
			if (_mappings.TryGetValue(currentType, out var value))
			{
				currentType = value;
				return true;
			}
			return false;
		}
	}
	internal class PreventUnknownTagsNodeTypeResolver : INodeTypeResolver
	{
		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		bool INodeTypeResolver.Resolve([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] NodeEvent nodeEvent, ref Type currentType)
		{
			if (nodeEvent != null && !nodeEvent.Tag.IsEmpty)
			{
				Mark start = nodeEvent.Start;
				Mark end = nodeEvent.End;
				throw new YamlException(in start, in end, $"Encountered an unresolved tag '{nodeEvent.Tag}'");
			}
			return false;
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	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([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] NodeEvent nodeEvent, ref Type currentType)
		{
			if (nodeEvent != null && !nodeEvent.Tag.IsEmpty && tagMappings.TryGetValue(nodeEvent.Tag, out var value))
			{
				currentType = value;
				return true;
			}
			return false;
		}
	}
	[Obsolete("The mechanism that this class uses to specify type names is non-standard. Register the tags explicitly instead of using this convention.")]
	internal sealed class TypeNameInTagNodeTypeResolver : INodeTypeResolver
	{
		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		bool INodeTypeResolver.Resolve([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] NodeEvent nodeEvent, ref Type currentType)
		{
			if (nodeEvent != null && !nodeEvent.Tag.IsEmpty)
			{
				Type type = Type.GetType(nodeEvent.Tag.Value.Substring(1), throwOnError: false);
				if (type != null)
				{
					currentType = type;
					return true;
				}
			}
			return false;
		}
	}
	internal sealed class YamlConvertibleTypeResolver : INodeTypeResolver
	{
		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		public bool Resolve([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] NodeEvent nodeEvent, ref Type currentType)
		{
			return typeof(IYamlConvertible).IsAssignableFrom(currentType);
		}
	}
	internal sealed class YamlSerializableTypeResolver : INodeTypeResolver
	{
		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		public bool Resolve([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] NodeEvent nodeEvent, ref Type currentType)
		{
			return typeof(IYamlSerializable).IsAssignableFrom(currentType);
		}
	}
}
namespace YamlDotNet.Serialization.NodeDeserializers
{
	internal sealed class ArrayNodeDeserializer : INodeDeserializer
	{
		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
		private sealed class ArrayList : IList, ICollection, IEnumerable
		{
			[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 1, 2 })]
			private object[] data;

			public bool IsFixedSize => false;

			public bool IsReadOnly => false;

			public object this[int index]
			{
				get
				{
					return data[index];
				}
				set
				{
					data[index] = value;
				}
			}

			public int Count { get; private set; }

			public bool IsSynchronized => false;

			[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(1)]
			public object SyncRoot
			{
				[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
				get
				{
					return data;
				}
			}

			public ArrayList()
			{
				Clear();
			}

			public int Add(object value)
			{
				if (Count == data.Length)
				{
					Array.Resize(ref data, data.Length * 2);
				}
				data[Count] = value;
				return Count++;
			}

			public void Clear()
			{
				data = new object[10];
				Count = 0;
			}

			bool IList.Contains(object value)
			{
				throw new NotSupportedException();
			}

			int IList.IndexOf(object value)
			{
				throw new NotSupportedException();
			}

			void IList.Insert(int index, object value)
			{
				throw new NotSupportedException();
			}

			void IList.Remove(object value)
			{
				throw new NotSupportedException();
			}

			void IList.RemoveAt(int index)
			{
				throw new NotSupportedException();
			}

			[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
			public void CopyTo(Array array, int index)
			{
				Array.Copy(data, 0, array, index, Count);
			}

			[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
			public IEnumerator GetEnumerator()
			{
				int i = 0;
				while (i < Count)
				{
					yield return data[i];
					int num = i + 1;
					i = num;
				}
			}
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		public bool Deserialize(IParser parser, Type expectedType, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] out object value)
		{
			if (!expectedType.IsArray)
			{
				value = false;
				return false;
			}
			Type? elementType = expectedType.GetElementType();
			ArrayList arrayList = new ArrayList();
			CollectionNodeDeserializer.DeserializeHelper(elementType, parser, nestedObjectDeserializer, arrayList, canUpdate: true);
			Array array = Array.CreateInstance(elementType, arrayList.Count);
			arrayList.CopyTo(array, 0);
			value = array;
			return true;
		}
	}
	internal abstract class CollectionDeserializer
	{
		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		protected static void DeserializeHelper(Type tItem, IParser parser, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 1, 1, 1, 2 })] 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)
					{
						Mark start = current?.Start ?? Mark.Empty;
						Mark end = current?.End ?? Mark.Empty;
						throw new ForwardAnchorNotSupportedException(in start, in end, "Forward alias references are not allowed because this type does not implement IList<>");
					}
					int index = result.Add(objectFactory.CreatePrimitive(tItem));
					valuePromise.ValueAvailable += [<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)] (object v) =>
					{
						result[index] = v;
					};
				}
				else
				{
					result.Add(obj);
				}
			}
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	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, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] 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, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 1, 1, 1, 2 })] 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)
					{
						Mark start = current?.Start ?? Mark.Empty;
						Mark end = current?.End ?? Mark.Empty;
						throw new ForwardAnchorNotSupportedException(in start, in end, "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 += [<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)] (object v) =>
					{
						result[index] = YamlDotNet.Serialization.Utilities.TypeConverter.ChangeType(v, tItem);
					};
				}
				else
				{
					result.Add(YamlDotNet.Serialization.Utilities.TypeConverter.ChangeType(obj, tItem));
				}
			}
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	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))
			{
				Mark start = propertyName.Start;
				Mark end = propertyName.End;
				throw new YamlException(in start, in end, $"Encountered duplicate key {key}");
			}
			result[key] = value;
		}

		protected virtual void Deserialize(Type tKey, Type tValue, IParser parser, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 1, 1, 1, 2 })] 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 += [<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)] (object v) =>
						{
							result[v] = value;
						};
						continue;
					}
					bool hasFirstPart = false;
					valuePromise2.ValueAvailable += [<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)] (object v) =>
					{
						if (hasFirstPart)
						{
							TryAssign(result, v, value, property);
						}
						else
						{
							key = v;
							hasFirstPart = true;
						}
					};
					valuePromise.ValueAvailable += [<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)] (object v) =>
					{
						if (hasFirstPart)
						{
							TryAssign(result, key, v, property);
						}
						else
						{
							value = v;
							hasFirstPart = true;
						}
					};
					continue;
				}
				if (key == null)
				{
					throw new ArgumentException("Empty key names are not supported yet.", "key");
				}
				if (valuePromise == null)
				{
					TryAssign(result, key, value, property);
					continue;
				}
				valuePromise.ValueAvailable += [<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)] (object v) =>
				{
					result[key] = v;
				};
			}
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	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, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] 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;
		}
	}
	internal sealed class EnumerableNodeDeserializer : INodeDeserializer
	{
		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		public bool Deserialize(IParser parser, Type expectedType, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] out object value)
		{
			Type type;
			if (expectedType == typeof(IEnumerable))
			{
				type = typeof(object);
			}
			else
			{
				Type implementedGenericInterface = ReflectionUtility.GetImplementedGenericInterface(expectedType, typeof(IEnumerable<>));
				if (implementedGenericInterface != expectedType)
				{
					value = null;
					return false;
				}
				type = implementedGenericInterface.GetGenericArguments()[0];
			}
			Type arg = typeof(List<>).MakeGenericType(type);
			value = nestedObjectDeserializer(parser, arg);
			return true;
		}
	}
	internal sealed class NullNodeDeserializer : INodeDeserializer
	{
		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		public bool Deserialize(IParser parser, Type expectedType, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] out object value)
		{
			value = null;
			if (parser.Accept<NodeEvent>(out var @event) && NodeIsNull(@event))
			{
				parser.SkipThisAndNestedEvents();
				return true;
			}
			return false;
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		private bool NodeIsNull(NodeEvent nodeEvent)
		{
			if (nodeEvent.Tag == "tag:yaml.org,2002:null")
			{
				return true;
			}
			if (nodeEvent is YamlDotNet.Core.Events.Scalar scalar && scalar.Style == ScalarStyle.Plain && !scalar.IsKey)
			{
				string value = scalar.Value;
				switch (value)
				{
				default:
					return value == "NULL";
				case "":
				case "~":
				case "null":
				case "Null":
					return true;
				}
			}
			return false;
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	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, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] 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))
			{
				YamlDotNet.Core.Events.Scalar scalar = parser.Consume<YamlDotNet.Core.Events.Scalar>();
				if (duplicateKeyChecking && !hashSet.Add(scalar.Value))
				{
					Mark start = scalar.Start;
					Mark end = scalar.End;
					throw new YamlException(in start, in 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 += [<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)] (object v) =>
						{
							object value3 = typeConverter.ChangeType(v, property.Type);
							property.Write(valueRef, value3);
						};
					}
					else
					{
						object value2 = typeConverter.ChangeType(obj, property.Type);
						property.Write(value, value2);
					}
				}
				catch (SerializationException ex)
				{
					Mark start = scalar.Start;
					Mark end = scalar.End;
					throw new YamlException(in start, in end, ex.Message);
				}
				catch (YamlException)
				{
					throw;
				}
				catch (Exception innerException)
				{
					Mark start = scalar.Start;
					Mark end = scalar.End;
					throw new YamlException(in start, in end, "Exception during deserialization", innerException);
				}
			}
			return true;
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	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, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] out object value)
		{
			if (!parser.TryConsume<YamlDotNet.Core.Events.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).Dispose();
			}
		}

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

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

		[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		private static object AttemptUnknownTypeDeserialization(YamlDotNet.Core.Events.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 "":
			case "~":
			case "null":
			case "Null":
			case "NULL":
				return null;
			case "true":
			case "True":
			case "TRUE":
				return true;
			case "false":
			case "False":
			case "FALSE":
				return false;
			default:
			{
				object value2;
				if (Regex.IsMatch(v, "0x[0-9a-fA-F]+"))
				{
					if (!TryAndSwallow(() => Convert.ToByte(v, 16), out value2) && !TryAndSwallow(() => Convert.ToInt16(v, 16), out value2) && !TryAndSwallow(() => Convert.ToInt32(v, 16), out value2) && !TryAndSwallow(() => Convert.ToInt64(v, 16), out value2) && !TryAndSwallow(() => Convert.ToUInt64(v, 16), out value2))
					{
						return v;
					}
				}
				else if (Regex.IsMatch(v, "0o[0-9a-fA-F]+"))
				{
					if (!TryAndSwallow(() => Convert.ToByte(v, 8), out value2) && !TryAndSwallow(() => Convert.ToInt16(v, 8), out value2) && !TryAndSwallow(() => Convert.ToInt32(v, 8), out value2) && !TryAndSwallow(() => Convert.ToInt64(v, 8), out value2) && !TryAndSwallow(() => Convert.ToUInt64(v, 8), out value2))
					{
						return v;
					}
				}
				else
				{
					if (!Regex.IsMatch(v, "[-+]?(\\.[0-9]+|[0-9]+(\\.[0-9]*)?)([eE][-+]?[0-9]+)?"))
					{
						if (Regex.IsMatch(v, "^[-+]?(\\.inf|\\.Inf|\\.INF)$"))
						{
							if (v.StartsWith("-"))
							{
								return float.NegativeInfinity;
							}
							return float.PositiveInfinity;
						}
						if (Regex.IsMatch(v, "^(\\.nan|\\.NaN|\\.NAN)$"))
						{
							return float.NaN;
						}
						return v;
					}
					if (!TryAndSwallow(() => byte.Parse(v), out value2) && !TryAndSwallow(() => short.Parse(v), out value2) && !TryAndSwallow(() => int.Parse(v), out value2) && !TryAndSwallow(() => long.Parse(v), out value2) && !TryAndSwallow(() => ulong.Parse(v), out value2) && !TryAndSwallow(() => float.Parse(v), out value2) && !TryAndSwallow(() => double.Parse(v), out value2))
					{
						return v;
					}
				}
				return value2;
			}
			}
		}

		private static bool TryAndSwallow(Func<object> attempt, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] out object value)
		{
			try
			{
				value = attempt();
				return true;
			}
			catch
			{
				value = null;
				return false;
			}
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal sealed class StaticArrayNodeDeserializer : INodeDeserializer
	{
		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
		private sealed class ArrayList : IList, ICollection, IEnumerable
		{
			[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 1, 2 })]
			private object[] data;

			public bool IsFixedSize => false;

			public bool IsReadOnly => false;

			public object this[int index]
			{
				get
				{
					return data[index];
				}
				set
				{
					data[index] = value;
				}
			}

			public int Count { get; private set; }

			public bool IsSynchronized => false;

			[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(1)]
			public object SyncRoot
			{
				[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
				get
				{
					return data;
				}
			}

			public ArrayList()
			{
				Clear();
			}

			public int Add(object value)
			{
				if (Count == data.Length)
				{
					Array.Resize(ref data, data.Length * 2);
				}
				data[Count] = value;
				return Count++;
			}

			public void Clear()
			{
				data = new object[10];
				Count = 0;
			}

			bool IList.Contains(object value)
			{
				throw new NotSupportedException();
			}

			int IList.IndexOf(object value)
			{
				throw new NotSupportedException();
			}

			void IList.Insert(int index, object value)
			{
				throw new NotSupportedException();
			}

			void IList.Remove(object value)
			{
				throw new NotSupportedException();
			}

			void IList.RemoveAt(int index)
			{
				throw new NotSupportedException();
			}

			[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
			public void CopyTo(Array array, int index)
			{
				Array.Copy(data, 0, array, index, Count);
			}

			[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
			public IEnumerator GetEnumerator()
			{
				int i = 0;
				while (i < Count)
				{
					yield return data[i];
					int num = i + 1;
					i = num;
				}
			}
		}

		private readonly StaticObjectFactory factory;

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

		public bool Deserialize(IParser parser, Type expectedType, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] out object value)
		{
			if (!factory.IsArray(expectedType))
			{
				value = false;
				return false;
			}
			Type valueType = factory.GetValueType(expectedType);
			ArrayList arrayList = new ArrayList();
			StaticCollectionNodeDeserializer.DeserializeHelper(valueType, parser, nestedObjectDeserializer, arrayList, factory);
			Array array = factory.CreateArray(expectedType, arrayList.Count);
			arrayList.CopyTo(array, 0);
			value = array;
			return true;
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	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, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] out object value)
		{
			if (!factory.IsList(expectedType))
			{
				value = null;
				return false;
			}
			DeserializeHelper(result: (IList)(value = factory.Create(expectedType) as IList), tItem: factory.GetValueType(expectedType), parser: parser, nestedObjectDeserializer: nestedObjectDeserializer, factory: factory);
			return true;
		}

		internal static void DeserializeHelper(Type tItem, IParser parser, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 1, 1, 1, 2 })] 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 += [<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)] (object v) =>
					{
						result[index] = v;
					};
				}
				else
				{
					result.Add(obj);
				}
			}
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	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, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] out object value)
		{
			if (_objectFactory.IsDictionary(expectedType))
			{
				if (!(_objectFactory.Create(expectedType) is IDictionary dictionary))
				{
					value = null;
					return false;
				}
				Type keyType = _objectFactory.GetKeyType(expectedType);
				Type valueType = _objectFactory.GetValueType(expectedType);
				value = dictionary;
				base.Deserialize(keyType, valueType, reader, nestedObjectDeserializer, dictionary);
				return true;
			}
			value = null;
			return false;
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	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, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] out object value)
		{
			IYamlTypeConverter yamlTypeConverter = converters.FirstOrDefault([<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)] (IYamlTypeConverter c) => c.Accepts(expectedType));
			if (yamlTypeConverter == null)
			{
				value = null;
				return false;
			}
			value = yamlTypeConverter.ReadYaml(parser, expectedType);
			return true;
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	internal sealed class YamlConvertibleNodeDeserializer : INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		public YamlConvertibleNodeDeserializer(IObjectFactory objectFactory)
		{
			this.objectFactory = objectFactory;
		}

		public bool Deserialize(IParser parser, Type expectedType, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] out object value)
		{
			if (typeof(IYamlConvertible).IsAssignableFrom(expectedType))
			{
				IYamlConvertible yamlConvertible = (IYamlConvertible)objectFactory.Create(expectedType);
				yamlConvertible.Read(parser, expectedType, [return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] (Type type) => nestedObjectDeserializer(parser, type));
				value = yamlConvertible;
				return true;
			}
			value = null;
			return false;
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	internal sealed class YamlSerializableNodeDeserializer : INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		public YamlSerializableNodeDeserializer(IObjectFactory objectFactory)
		{
			this.objectFactory = objectFactory;
		}

		public bool Deserialize(IParser parser, Type expectedType, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] out object value)
		{
			if (typeof(IYamlSerializable).IsAssignableFrom(expectedType))
			{
				IYamlSerializable yamlSerializable = (IYamlSerializable)objectFactory.Create(expectedType);
				yamlSerializable.ReadYaml(parser);
				value = yamlSerializable;
				return true;
			}
			value = null;
			return false;
		}
	}
}
namespace YamlDotNet.Serialization.NamingConventions
{
	internal sealed class CamelCaseNamingConvention : INamingConvention
	{
		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(1)]
		public static readonly INamingConvention Instance = new CamelCaseNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public CamelCaseNamingConvention()
		{
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		public string Apply(string value)
		{
			return value.ToCamelCase();
		}
	}
	internal sealed class HyphenatedNamingConvention : INamingConvention
	{
		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(1)]
		public static readonly INamingConvention Instance = new HyphenatedNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public HyphenatedNamingConvention()
		{
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		public string Apply(string value)
		{
			return value.FromCamelCase("-");
		}
	}
	internal sealed class LowerCaseNamingConvention : INamingConvention
	{
		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(1)]
		public static readonly INamingConvention Instance = new LowerCaseNamingConvention();

		private LowerCaseNamingConvention()
		{
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		public string Apply(string value)
		{
			return value.ToCamelCase().ToLower();
		}
	}
	internal sealed class NullNamingConvention : INamingConvention
	{
		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(1)]
		public static readonly INamingConvention Instance = new NullNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public NullNamingConvention()
		{
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		public string Apply(string value)
		{
			return value;
		}
	}
	internal sealed class PascalCaseNamingConvention : INamingConvention
	{
		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(1)]
		public static readonly INamingConvention Instance = new PascalCaseNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public PascalCaseNamingConvention()
		{
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		public string Apply(string value)
		{
			return value.ToPascalCase();
		}
	}
	internal sealed class UnderscoredNamingConvention : INamingConvention
	{
		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(1)]
		public static readonly INamingConvention Instance = new UnderscoredNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public UnderscoredNamingConvention()
		{
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		public string Apply(string value)
		{
			return value.FromCamelCase("_");
		}
	}
}
namespace YamlDotNet.Serialization.EventEmitters
{
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	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);
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	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);
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal sealed class TypeAssigningEventEmitter : ChainedEventEmitter
	{
		private readonly bool requireTagWhenStaticAndActualTypesAreDifferent;

		private readonly IDictionary<Type, TagName> tagMappings;

		private readonly bool quoteNecessaryStrings;

		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		private readonly Regex isSpecialStringValue_Regex;

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

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

		public 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)) ? ScalarStyle.DoubleQuoted : ScalarStyle.Any);
					}
					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)) ? ScalarStyle.DoubleQuoted : ScalarStyle.Any);
					break;
				case TypeCode.DateTime:
					eventInfo.Tag = DefaultSchema.Tags.Timestamp;
					eventInfo.RenderedValue = YamlFormatter.FormatDateTime(value);
					break;
				case TypeCode.Empty:
					eventInfo.Tag = JsonSchema.Tags.Null;
					eventInfo.RenderedValue = "";
					break;
				default:
					if (eventInfo.Source.Type == typeof(TimeSpan))
					{
						eventInfo.RenderedValue = YamlFormatter.FormatTimeSpan(value);
						break;
					}
					throw new NotSupportedException($"TypeCode.{typeCode} is not supported.");
				}
			}
			eventInfo.IsPlainImplicit = true;
			if (eventInfo.Style == ScalarStyle.Any)
			{
				eventInfo.Style = style;
			}
			base.Emit(eventInfo, emitter);
		}

		public override void Emit(MappingStartEventInfo eventInfo, IEmitter emitter)
		{
			AssignTypeIfNeeded(eventInfo);
			base.Emit(eventInfo, emitter);
		}

		public override void Emit(SequenceStartEventInfo eventInfo, IEmitter emitter)
		{
			AssignTypeIfNeeded(eventInfo);
			base.Emit(eventInfo, emitter);
		}

		private void AssignTypeIfNeeded(ObjectEventInfo eventInfo)
		{
			if (tagMappings.TryGetValue(eventInfo.Source.Type, out var value))
			{
				eventInfo.Tag = value;
			}
			else if (requireTagWhenStaticAndActualTypesAreDifferent && eventInfo.Source.Value != null && eventInfo.Source.Type != eventInfo.Source.StaticType)
			{
				throw new YamlException("Cannot serialize type '" + eventInfo.Source.Type.FullName + "' where a '" + eventInfo.Source.StaticType.FullName + "' was expected because no tag mapping has been registered for '" + eventInfo.Source.Type.FullName + "', which means that it won't be possible to deserialize the document.\nRegister a tag mapping using the SerializerBuilder.WithTagMapping method.\n\nE.g: builder.WithTagMapping(\"!" + eventInfo.Source.Type.Name + "\", typeof(" + eventInfo.Source.Type.FullName + "));");
			}
		}

		private bool IsSpecialStringValue(string value)
		{
			if (value.Trim() == string.Empty)
			{
				return true;
			}
			return isSpecialStringValue_Regex?.IsMatch(value) ?? false;
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal sealed class WriterEventEmitter : IEventEmitter
	{
		void IEventEmitter.Emit(AliasEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new YamlDotNet.Core.Events.AnchorAlias(eventInfo.Alias));
		}

		void IEventEmitter.Emit(ScalarEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(eventInfo.Anchor, eventInfo.Tag, eventInfo.RenderedValue, eventInfo.Style, eventInfo.IsPlainImplicit, eventInfo.IsQuotedImplicit));
		}

		void IEventEmitter.Emit(MappingStartEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new MappingStart(eventInfo.Anchor, eventInfo.Tag, eventInfo.IsImplicit, eventInfo.Style));
		}

		void IEventEmitter.Emit(MappingEndEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new MappingEnd());
		}

		void IEventEmitter.Emit(SequenceStartEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new SequenceStart(eventInfo.Anchor, eventInfo.Tag, eventInfo.IsImplicit, eventInfo.Style));
		}

		void IEventEmitter.Emit(SequenceEndEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new SequenceEnd());
		}
	}
}
namespace YamlDotNet.Serialization.Converters
{
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	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, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] IFormatProvider provider = null, bool doubleQuotes = false, params string[] formats)
		{
			this.kind = ((kind == DateTimeKind.Unspecified) ? DateTimeKind.Utc : kind);
			this.provider = provider ?? CultureInfo.InvariantCulture;
			this.doubleQuotes = doubleQuotes;
			this.formats = formats.DefaultIfEmpty("G").ToArray();
		}

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

		public object ReadYaml(IParser parser, Type type)
		{
			return EnsureDateTimeKind(DateTime.ParseExact(parser.Consume<YamlDotNet.Core.Events.Scalar>().Value, style: (kind == DateTimeKind.Local) ? DateTimeStyles.AssumeLocal : DateTimeStyles.AssumeUniversal, formats: formats, provider: provider), kind);
		}

		public void WriteYaml(IEmitter emitter, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object value, Type type)
		{
			DateTime dateTime = (DateTime)value;
			string value2 = ((kind == DateTimeKind.Local) ? dateTime.ToLocalTime() : dateTime.ToUniversalTime()).ToString(formats.First(), provider);
			emitter.Emit(new YamlDotNet.Core.Events.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;
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	internal class GuidConverter : IYamlTypeConverter
	{
		private readonly bool jsonCompatible;

		public GuidConverter(bool jsonCompatible)
		{
			this.jsonCompatible = jsonCompatible;
		}

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

		public object ReadYaml(IParser parser, Type type)
		{
			return new Guid(parser.Consume<YamlDotNet.Core.Events.Scalar>().Value);
		}

		public void WriteYaml(IEmitter emitter, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object value, Type type)
		{
			Guid guid = (Guid)value;
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, guid.ToString("D"), jsonCompatible ? ScalarStyle.DoubleQuoted : ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: false));
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	internal class SystemTypeConverter : IYamlTypeConverter
	{
		public bool Accepts(Type type)
		{
			return typeof(Type).IsAssignableFrom(type);
		}

		public object ReadYaml(IParser parser, Type type)
		{
			return Type.GetType(parser.Consume<YamlDotNet.Core.Events.Scalar>().Value, throwOnError: true);
		}

		public void WriteYaml(IEmitter emitter, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object value, Type type)
		{
			Type type2 = (Type)value;
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, type2.AssemblyQualifiedName, ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: false));
		}
	}
}
namespace YamlDotNet.Serialization.BufferedDeserialization
{
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal interface ITypeDiscriminatingNodeDeserializerOptions
	{
		void AddTypeDiscriminator(ITypeDiscriminator discriminator);

		void AddKeyValueTypeDiscriminator<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] T>(string discriminatorKey, IDictionary<string, Type> valueTypeMapping);

		void AddUniqueKeyTypeDiscriminator<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] T>(IDictionary<string, Type> uniqueKeyTypeMapping);
	}
	internal class ParserBuffer : IParser
	{
		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(1)]
		private readonly LinkedList<ParsingEvent> buffer;

		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 2, 1 })]
		private LinkedListNode<ParsingEvent> current;

		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		public ParsingEvent Current
		{
			[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
			get
			{
				return current?.Value;
			}
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		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;
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	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, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] out object value)
		{
			if (!reader.Accept<MappingStart>(out var _))
			{
				value = null;
				return false;
			}
			IEnumerable<ITypeDiscriminator> enumerable = typeDiscriminators.Where([<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)] (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)
			{
				Mark end = reader.Current.End;
				throw new YamlException(in start, in end, "Failed to buffer yaml node", innerException);
			}
			try
			{
				foreach (ITypeDiscriminator item in enumerable)
				{
					parserBuffer.Reset();
					if (item.TryDiscriminate(parserBuffer, out var suggestedType))
					{
						expectedType2 = suggestedType;
						break;
					}
				}
			}
			catch (Exception innerException2)
			{
				Mark end = reader.Current.End;
				throw new YamlException(in start, in 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;
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal class TypeDiscriminatingNodeDeserializerOptions : ITypeDiscriminatingNodeDeserializerOptions
	{
		internal readonly List<ITypeDiscriminator> discriminators = new List<ITypeDiscriminator>();

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

		public void AddKeyValueTypeDiscriminator<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] T>(string discriminatorKey, IDictionary<string, Type> valueTypeMapping)
		{
			discriminators.Add(new KeyValueTypeDiscriminator(typeof(T), discriminatorKey, valueTypeMapping));
		}

		public void AddUniqueKeyTypeDiscriminator<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] T>(IDictionary<string, Type> uniqueKeyTypeMapping)
		{
			discriminators.Add(new UniqueKeyTypeDiscriminator(typeof(T), uniqueKeyTypeMapping));
		}
	}
}
namespace YamlDotNet.Serialization.BufferedDeserialization.TypeDiscriminators
{
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal interface ITypeDiscriminator
	{
		Type BaseType { get; }

		bool TryDiscriminate(IParser buffer, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] out Type suggestedType);
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	internal class KeyValueTypeDiscriminator : ITypeDiscriminator
	{
		private readonly string targetKey;

		private readonly IDictionary<string, Type> typeMapping;

		public Type BaseType { get; private set; }

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

		public bool TryDiscriminate(IParser parser, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] out Type suggestedType)
		{
			if (parser.TryFindMappingEntry((YamlDotNet.Core.Events.Scalar scalar) => targetKey == scalar.Value, out var _, out var value) && value is YamlDotNet.Core.Events.Scalar scalar2 && typeMapping.TryGetValue(scalar2.Value, out var value2))
			{
				suggestedType = value2;
				return true;
			}
			suggestedType = null;
			return false;
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	internal class UniqueKeyTypeDiscriminator : ITypeDiscriminator
	{
		private readonly IDictionary<string, Type> typeMapping;

		public Type BaseType { get; private set; }

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

		public bool TryDiscriminate(IParser parser, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] out Type suggestedType)
		{
			if (parser.TryFindMappingEntry((YamlDotNet.Core.Events.Scalar scalar) => typeMapping.ContainsKey(scalar.Value), out var key, out var _))
			{
				suggestedType = typeMapping[key.Value];
				return true;
			}
			suggestedType = null;
			return false;
		}
	}
}
namespace YamlDotNet.RepresentationModel
{
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	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 var value))
			{
				return value;
			}
			throw new AnchorNotFoundException(in start, in end, $"The anchor '{anchor}' does not exists");
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
		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);
			}
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	internal class EmitterState
	{
		public HashSet<AnchorName> EmittedAnchors { get; } = new HashSet<AnchorName>();

	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal interface IYamlVisitor
	{
		void Visit(YamlStream stream);

		void Visit(YamlDocument document);

		void Visit(YamlScalarNode scalar);

		void Visit(YamlSequenceNode sequence);

		void Visit(YamlMappingNode mapping);
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal class LibYamlEventStream
	{
		private readonly IParser parser;

		public LibYamlEventStream(IParser iParser)
		{
			parser = iParser ?? throw new ArgumentNullException("iParser");
		}

		public void WriteTo(TextWriter textWriter)
		{
			while (parser.MoveNext())
			{
				ParsingEvent current = parser.Current;
				if (!(current is YamlDotNet.Core.Events.AnchorAlias anchorAlias))
				{
					if (!(current is YamlDotNet.Core.Events.DocumentEnd documentEnd))
					{
						if (!(current is YamlDotNet.Core.Events.DocumentStart documentStart))
						{
							if (!(current is MappingEnd))
							{
								if (!(current is MappingStart nodeEvent))
								{
									if (!(current is YamlDotNet.Core.Events.Scalar scalar))
									{
										if (!(current is SequenceEnd))
										{
											if (!(current is SequenceStart nodeEvent2))
											{
												if (!(current is YamlDotNet.Core.Events.StreamEnd))
												{
													if (current is YamlDotNet.Core.Events.StreamStart)
													{
														textWriter.Write("+STR");
													}
												}
												else
												{
													textWriter.Write("-STR");
												}
											}
											else
											{
												textWriter.Write("+SEQ");
												WriteAnchorAndTag(textWriter, nodeEvent2);
											}
										}
										else
										{
											textWriter.Write("-SEQ");
										}
									}
									else
									{
										textWriter.Write("=VAL");
										WriteAnchorAndTag(textWriter, scalar);
										switch (scalar.Style)
										{
										case ScalarStyle.DoubleQuoted:
											textWriter.Write(" \"");
											break;
										case ScalarStyle.SingleQuoted:
											textWriter.Write(" '");
											break;
										case ScalarStyle.Folded:
											textWriter.Write(" >");
											break;
										case ScalarStyle.Literal:
											textWriter.Write(" |");
											break;
										default:
											textWriter.Write(" :");
											break;
										}
										string value = scalar.Value;
										foreach (char c in value)
										{
											switch (c)
											{
											case '\b':
												textWriter.Write("\\b");
												break;
											case '\t':
												textWriter.Write("\\t");
												break;
											case '\n':
												textWriter.Write("\\n");
												break;
											case '\r':
												textWriter.Write("\\r");
												break;
											case '\\':
												textWriter.Write("\\\\");
												break;
											default:
												textWriter.Write(c);
												break;
											}
										}
									}
								}
								else
								{
									textWriter.Write("+MAP");
									WriteAnchorAndTag(textWriter, nodeEvent);
								}
							}
							else
							{
								textWriter.Write("-MAP");
							}
						}
						else
						{
							textWriter.Write("+DOC");
							if (!documentStart.IsImplicit)
							{
								textWriter.Write(" ---");
							}
						}
					}
					else
					{
						textWriter.Write("-DOC");
						if (!documentEnd.IsImplicit)
						{
							textWriter.Write(" ...");
						}
					}
				}
				else
				{
					textWriter.Write("=ALI *");
					textWriter.Write(anchorAlias.Value);
				}
				textWriter.WriteLine();
			}
		}

		private void WriteAnchorAndTag(TextWriter textWriter, NodeEvent nodeEvent)
		{
			if (!nodeEvent.Anchor.IsEmpty)
			{
				textWriter.Write(" &");
				textWriter.Write(nodeEvent.Anchor);
			}
			if (!nodeEvent.Tag.IsEmpty)
			{
				textWriter.Write(" <");
				textWriter.Write(nodeEvent.Tag.Value);
				textWriter.Write(">");
			}
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	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.");
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
		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;
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal class YamlDocument
	{
		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
		private class AnchorAssigningVisitor : YamlVisitorBase
		{
			private readonly HashSet<AnchorName> existingAnchors = new HashSet<AnchorName>();

			private readonly Dictionary<YamlNode, bool> visitedNodes = new Dictionary<YamlNode, bool>();

			public void AssignAnchors(YamlDocument document)
			{
				existingAnchors.Clear();
				visitedNodes.Clear();
				document.Accept(this);
				Random random = new Random();
				foreach (KeyValuePair<YamlNode, bool> visitedNode in visitedNodes)
				{
					if (!visitedNode.Value)
					{
						continue;
					}
					AnchorName anchorName;
					if (!visitedNode.Key.Anchor.IsEmpty && !existingAnchors.Contains(visitedNode.Key.Anchor))
					{
						anchorName = visitedNode.Key.Anchor;
					}
					else
					{
						do
						{
							anchorName = new AnchorName(random.Next().ToString(CultureInfo.InvariantCulture));
						}
						while (existingAnchors.Contains(anchorName));
					}
					existingAnchors.Add(anchorName);
					visitedNode.Key.Anchor = anchorName;
				}
			}

			private bool VisitNodeAndFindDuplicates(YamlNode node)
			{
				if (visitedNodes.TryGetValue(node, out var value))
				{
					if (!value)
					{
						visitedNodes[node] = true;
					}
					return !value;
				}
				visitedNodes.Add(node, value: false);
				return false;
			}

			public override void Visit(YamlScalarNode scalar)
			{
				VisitNodeAndFindDuplicates(scalar);
			}

			public override void Visit(YamlMappingNode mapping)
			{
				if (!VisitNodeAndFindDuplicates(mapping))
				{
					base.Visit(mapping);
				}
			}

			public override void Visit(YamlSequenceNode sequence)
			{
				if (!VisitNodeAndFindDuplicates(sequence))
				{
					base.Visit(sequence);
				}
			}
		}

		public YamlNode RootNode { get; private set; }

		public IEnumerable<YamlNode> AllNodes => RootNode.AllNodes;

		public YamlDocument(YamlNode rootNode)
		{
			RootNode = rootNode;
		}

		public YamlDocument(string rootNode)
		{
			RootNode = new YamlScalarNode(rootNode);
		}

		internal YamlDocument(IParser parser)
		{
			DocumentLoadingState documentLoadingState = new DocumentLoadingState();
			parser.Consume<YamlDotNet.Core.Events.DocumentStart>();
			YamlDotNet.Core.Events.DocumentEnd @event;
			while (!parser.TryConsume<YamlDotNet.Core.Events.DocumentEnd>(out @event))
			{
				RootNode = YamlNode.ParseNode(parser, documentLoadingState);
				if (RootNode is YamlAliasNode)
				{
					throw new YamlException("A document cannot contain only an alias");
				}
			}
			documentLoadingState.ResolveAliases();
			if (RootNode == null)
			{
				throw new ArgumentException("Atempted to parse an empty document");
			}
		}

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

		internal void Save(IEmitter emitter, bool assignAnchors = true)
		{
			if (assignAnchors)
			{
				AssignAnchors();
			}
			emitter.Emit(new YamlDotNet.Core.Events.DocumentStart());
			RootNode.Save(emitter, new EmitterState());
			emitter.Emit(new YamlDotNet.Core.Events.DocumentEnd(isImplicit: false));
		}

		public void Accept(IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	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)
				{
					Mark start = yamlNode.Start;
					Mark end = yamlNode.End;
					throw new YamlException(in start, in end, "Duplicate key", innerException);
				}
				flag = flag || yamlNode is YamlAliasNode || yamlNode2 is YamlAliasNode;
			}
			if (flag)
			{
				state.AddNodeWithUnresolvedAliases(this);
			}
		}

		public YamlMappingNode()
		{
		}

		public YamlMappingNode([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 1, 0, 1, 1 })] params KeyValuePair<YamlNode, YamlNode>[] children)
			: this((IEnumerable<KeyValuePair<YamlNode, YamlNode>>)children)
		{
		}

		public YamlMappingNode([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 1, 0, 1, 1 })] 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);
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
		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 var 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).Dispose();
			}
		}

		[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 1, 0, 1, 1 })]
		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;
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal abstract class YamlNode
	{
		private const int MaximumRecursionLevel = 1000;

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

		public AnchorName Anchor { get; set; }

		public TagName Tag { get; set; }

		public Mark Start { get; private set; } = Mark.Empty;


		public Mark End { get; private set; } = Mark.Empty;


		public IEnumerable<YamlNode> AllNodes
		{
			get
			{
				RecursionLevel level = new RecursionLevel(1000);
				return SafeAllNodes(level);
			}
		}

		public abstract YamlNodeType NodeType { get; }

		public YamlNode this[int index]
		{
			get
			{
				if (!(this is YamlSequenceNode yamlSequenceNode))
				{
					throw new ArgumentException($"Accessed '{NodeType}' with an invalid index: {index}. Only Sequences can be indexed by number.");
				}
				return yamlSequenceNode.Children[index];
			}
		}

		public YamlNode this[YamlNode key]
		{
			get
			{
				if (!(this is YamlMappingNode yamlMappingNode))
				{
					throw new ArgumentException($"Accessed '{NodeType}' with an invalid index: {key}. Only Mappings can be indexed by key.");
				}
				return yamlMappingNode.Children[key];
			}
		}

		internal void Load(NodeEvent yamlEvent, DocumentLoadingState state)
		{
			Tag = yamlEvent.Tag;
			if (!yamlEvent.Anchor.IsEmpty)
			{
				Anchor = yamlEvent.Anchor;
				state.AddAnchor(this);
			}
			Start = yamlEvent.Start;
			End = yamlEvent.End;
		}

		internal static YamlNode ParseNode(IParser parser, DocumentLoadingState state)
		{
			if (parser.Accept<YamlDotNet.Core.Events.Scalar>(out var _))
			{
				return new YamlScalarNode(parser, state);
			}
			if (parser.Accept<SequenceStart>(out var _))
			{
				return new YamlSequenceNode(parser, state);
			}
			if (parser.Accept<MappingStart>(out var _))
			{
				return new YamlMappingNode(parser, state);
			}
			if (parser.TryConsume<YamlDotNet.Core.Events.AnchorAlias>(out var event4))
			{
				if (!state.TryGetNode(event4.Value, out var node))
				{
					return new YamlAliasNode(event4.Value);
				}
				return node;
			}
			throw new ArgumentException("The current event is of an unsupported type.", "parser");
		}

		internal abstract void ResolveAliases(DocumentLoadingState state);

		internal void Save(IEmitter emitter, EmitterState state)
		{
			if (!Anchor.IsEmpty && !state.EmittedAnchors.Add(Anchor))
			{
				emitter.Emit(new YamlDotNet.Core.Events.AnchorAlias(Anchor));
			}
			else
			{
				Emit(emitter, state);
			}
		}

		internal abstract void Emit(IEmitter emitter, EmitterState state);

		public abstract void Accept(IYamlVisitor visitor);

		public override string ToString()
		{
			RecursionLevel recursionLevel = new RecursionLevel(1000);
			return ToString(recursionLevel);
		}

		internal abstract string ToString(RecursionLevel level);

		internal abstract IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level);

		public static implicit operator YamlNode(string value)
		{
			return new YamlScalarNode(value);
		}

		public static implicit operator YamlNode(string[] sequence)
		{
			return new YamlSequenceNode(((IEnumerable<string>)sequence).Select((Func<string, YamlNode>)([<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)] (string i) => i)));
		}

		[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		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;
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	internal sealed class YamlNodeIdentityEqualityComparer : IEqualityComparer<YamlNode>
	{
		public bool Equals([AllowNull] YamlNode x, [AllowNull] YamlNode y)
		{
			return x == y;
		}

		public int GetHashCode(YamlNode obj)
		{
			return obj.GetHashCode();
		}
	}
	internal enum YamlNodeType
	{
		Alias,
		Mapping,
		Scalar,
		Sequence
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[DebuggerDisplay("{Value}")]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal sealed class YamlScalarNode : YamlNode, IYamlConvertible
	{
		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		[field: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		public string Value
		{
			[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
			get;
			[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
			set;
		}

		public ScalarStyle Style { get; set; }

		public override YamlNodeType NodeType => YamlNodeType.Scalar;

		internal YamlScalarNode(IParser parser, DocumentLoadingState state)
		{
			Load(parser, state);
		}

		private void Load(IParser parser, DocumentLoadingState state)
		{
			YamlDotNet.Core.Events.Scalar scalar = parser.Consume<YamlDotNet.Core.Events.Scalar>();
			Load(scalar, state);
			Value = scalar.Value;
			Style = scalar.Style;
		}

		public YamlScalarNode()
		{
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
		public YamlScalarNode(string value)
		{
			Value = value;
		}

		internal override void ResolveAliases(DocumentLoadingState state)
		{
			throw new NotSupportedException("Resolving an alias on a scalar node does not make sense");
		}

		internal override void Emit(IEmitter emitter, EmitterState state)
		{
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(base.Anchor, base.Tag, Value ?? string.Empty, Style, base.Tag.IsEmpty, isQuotedImplicit: false));
		}

		public override void Accept(IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
		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);
		}

		[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		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());
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[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);
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
		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).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());
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	internal class YamlStream : IEnumerable<YamlDocument>, IEnumerable
	{
		private readonly IList<YamlDocument> documents = new List<YamlDocument>();

		public IList<YamlDocument> Documents => documents;

		public YamlStream()
		{
		}

		public YamlStream(params YamlDocument[] documents)
			: this((IEnumerable<YamlDocument>)documents)
		{
		}

		public YamlStream(IEnumerable<YamlDocument> documents)
		{
			foreach (YamlDocument document in documents)
			{
				this.documents.Add(document);
			}
		}

		public void Add(YamlDocument document)
		{
			documents.Add(document);
		}

		public void Load(TextReader input)
		{
			Load(new Parser(input));
		}

		public void Load(IParser parser)
		{
			documents.Clear();
			parser.Consume<YamlDotNet.Core.Events.StreamStart>();
			YamlDotNet.Core.Events.StreamEnd @event;
			while (!parser.TryConsume<YamlDotNet.Core.Events.StreamEnd>(out @event))
			{
				YamlDocument item = new YamlDocument(parser);
				documents.Add(item);
			}
		}

		public void Save(TextWriter output)
		{
			Save(output, assignAnchors: true);
		}

		public void Save(TextWriter output, bool assignAnchors)
		{
			Save(new Emitter(output), assignAnchors);
		}

		public void Save(IEmitter emitter, bool assignAnchors)
		{
			emitter.Emit(new YamlDotNet.Core.Events.StreamStart());
			foreach (YamlDocument document in documents)
			{
				document.Save(emitter, assignAnchors);
			}
			emitter.Emit(new YamlDotNet.Core.Events.StreamEnd());
		}

		public void Accept(IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		public IEnumerator<YamlDocument> GetEnumerator()
		{
			return documents.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	[Obsolete("Use YamlVisitorBase")]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	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);
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	internal abstract class YamlVisitorBase : IYamlVisitor
	{
		public virtual void Visit(YamlStream stream)
		{
			VisitChildren(stream);
		}

		public virtual void Visit(YamlDocument document)
		{
			VisitChildren(document);
		}

		public virtual void Visit(YamlScalarNode scalar)
		{
		}

		public virtual void Visit(YamlSequenceNode sequence)
		{
			VisitChildren(sequence);
		}

		public virtual void Visit(YamlMappingNode mapping)
		{
			VisitChildren(mapping);
		}

		protected virtual void VisitPair(YamlNode key, YamlNode value)
		{
			key.Accept(this);
			value.Accept(this);
		}

		protected virtual void VisitChildren(YamlStream stream)
		{
			foreach (YamlDocument document in stream.Documents)
			{
				document.Accept(this);
			}
		}

		protected virtual void VisitChildren(YamlDocument document)
		{
			if (document.RootNode != null)
			{
				document.RootNode.Accept(this);
			}
		}

		protected virtual void VisitChildren(YamlSequenceNode sequence)
		{
			foreach (YamlNode child in sequence.Children)
			{
				child.Accept(this);
			}
		}

		protected virtual void VisitChildren(YamlMappingNode mapping)
		{
			foreach (KeyValuePair<YamlNode, YamlNode> child in mapping.Children)
			{
				VisitPair(child.Key, child.Value);
			}
		}
	}
}
namespace YamlDotNet.Helpers
{
	[DebuggerStepThrough]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal sealed class ConcurrentObjectPool<T> where T : class
	{
		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)]
		[DebuggerDisplay("{value,nq}")]
		private struct Element
		{
			[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
			internal T value;
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)]
		internal delegate T Factory();

		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		private T firstItem;

		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 1, 0, 0 })]
		private readonly Element[] items;

		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 1, 0 })]
		private readonly Factory factory;

		internal ConcurrentObjectPool([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 1, 0 })] Factory factory)
			: this(factory, Environment.ProcessorCount * 2)
		{
		}

		internal ConcurrentObjectPool([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 1, 0 })] Factory factory, int size)
		{
			this.factory = factory;
			items = new Element[size - 1];
		}

		private T CreateInstance()
		{
			return factory();
		}

		internal T Allocate()
		{
			T val = firstItem;
			if (val == null || val != Interlocked.CompareExchange(ref firstItem, null, val))
			{
				val = AllocateSlow();
			}
			return val;
		}

		private T AllocateSlow()
		{
			Element[] array = items;
			for (int i = 0; i < array.Length; i++)
			{
				T value = array[i].value;
				if (value != null && value == Interlocked.CompareExchange(ref array[i].value, null, value))
				{
					return value;
				}
			}
			return CreateInstance();
		}

		internal void Free(T obj)
		{
			if (firstItem == null)
			{
				firstItem = obj;
			}
			else
			{
				FreeSlow(obj);
			}
		}

		private void FreeSlow(T obj)
		{
			Element[] array = items;
			for (int i = 0; i < array.Length; i++)
			{
				if (array[i].value == null)
				{
					array[i].value = obj;
					break;
				}
			}
		}

		[Conditional("DEBUG")]
		private void Validate(object obj)
		{
			Element[] array = items;
			for (int i = 0; i < array.Length && array[i].value != null; i++)
			{
			}
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] TMemberInfo>(LambdaExpression lambdaExpression) where TMemberInfo : MemberInfo
		{
			if (lambdaExpression.Parameters.Count != 1)
			{
				return null;
			}
			Expression expression = lambdaExpression.Body;
			if (expression is UnaryExpression unaryExpression)
			{
				if (unaryExpression.NodeType != ExpressionType.Convert)
				{
					return null;
				}
				expression = unaryExpression.Operand;
			}
			if (expression is MemberExpression memberExpression)
			{
				if (memberExpression.Expression != lambdaExpression.Parameters[0])
				{
					return null;
				}
				return memberExpression.Member as TMemberInfo;
			}
			return null;
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	internal sealed class GenericCollectionToNonGenericAdapter<T> : IList, ICollection, IEnumerable
	{
		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(1)]
		private readonly ICollection<T> genericCollection;

		public bool IsFixedSize
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public bool IsReadOnly
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public object this[int index]
		{
			get
			{
				throw new NotSupportedException();
			}
			set
			{
				((IList<T>)genericCollection)[index] = (T)value;
			}
		}

		public int Count
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public bool IsSynchronized
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(1)]
		public object SyncRoot
		{
			[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
			get
			{
				throw new NotSupportedException();
			}
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		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();
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		public void CopyTo(Array array, int index)
		{
			throw new NotSupportedException();
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		public IEnumerator GetEnumerator()
		{
			return genericCollection.GetEnumerator();
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	internal sealed class GenericDictionaryToNonGenericAdapter<TKey, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] TValue> : IDictionary, ICollection, IEnumerable
	{
		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
		private class DictionaryEnumerator : IDictionaryEnumerator, IEnumerator
		{
			[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 1, 0, 1, 1 })]
			private readonly IEnumerator<KeyValuePair<TKey, TValue>> enumerator;

			public DictionaryEntry Entry => new DictionaryEntry(Key, Value);

			public object Key => enumerator.Current.Key;

			[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
			public object Value
			{
				[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
				get
				{
					return enumerator.Current.Value;
				}
			}

			public object Current => Entry;

			public DictionaryEnumerator([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 1, 0, 1, 1 })] IEnumerator<KeyValuePair<TKey, TValue>> enumerator)
			{
				this.enumerator = enumerator;
			}

			public bool MoveNext()
			{
				return enumerator.MoveNext();
			}

			public void Reset()
			{
				enumerator.Reset();
			}
		}

		private readonly IDictionary<TKey, TValue> genericDictionary;

		public bool IsFixedSize
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public bool IsReadOnly
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public ICollection Keys
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public ICollection Values
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		public object this[object key]
		{
			[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
			get
			{
				throw new NotSupportedException();
			}
			[param: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
			set
			{
				genericDictionary[(TKey)key] = (TValue)value;
			}
		}

		public int Count
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public bool IsSynchronized
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public object SyncRoot
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public GenericDictionaryToNonGenericAdapter(IDictionary<TKey, TValue> genericDictionary)
		{
			this.genericDictionary = genericDictionary ?? throw new ArgumentNullException("genericDictionary");
		}

		public void Add(object key, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] object value)
		{
			throw new NotSupportedException();
		}

		public void Clear()
		{
			throw new NotSupportedException();
		}

		public bool Contains(object key)
		{
			throw new NotSupportedException();
		}

		public IDictionaryEnumerator GetEnumerator()
		{
			return new DictionaryEnumerator(genericDictionary.GetEnumerator());
		}

		public void Remove(object key)
		{
			throw new NotSupportedException();
		}

		public void CopyTo(Array array, int index)
		{
			throw new NotSupportedException();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal interface IOrderedDictionary<TKey, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] TValue> : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable
	{
		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 0, 1, 1 })]
		KeyValuePair<TKey, TValue> this[int index]
		{
			[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 0, 1, 1 })]
			get;
			[param: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 0, 1, 1 })]
			set;
		}

		void Insert(int index, TKey key, TValue value);

		void RemoveAt(int index);
	}
	internal static class NumberExtensions
	{
		public static bool IsPowerOfTwo(this int value)
		{
			return (value & (value - 1)) == 0;
		}
	}
	[Serializable]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	internal sealed class OrderedDictionary<TKey, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] TValue> : IOrderedDictionary<TKey, TValue>, IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable
	{
		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
		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([<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)] (KeyValuePair<TKey, TValue> kvp) => kvp.Key).GetEnumerator();
			}

			public bool Remove(TKey item)
			{
				throw new NotSupportedException();
			}

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

		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
		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([<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)] (KeyValuePair<TKey, TValue> kvp) => kvp.Value).GetEnumerator();
			}

			public bool Remove(TValue item)
			{
				throw new NotSupportedException();
			}

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

		[NonSerialized]
		private Dictionary<TKey, TValue> dictionary;

		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 1, 0, 1, 1 })]
		private readonly List<KeyValuePair<TKey, TValue>> list;

		private readonly IEqualityComparer<TKey> comparer;

		public TValue this[TKey key]
		{
			get
			{
				return dictionary[key];
			}
			set
			{
				if (dictionary.ContainsKey(key))
				{
					int index = list.FindIndex(([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 0, 1, 1 })] KeyValuePair<TKey, TValue> kvp) => comparer.Equals(kvp.Key, key));
					dictionary[key] = value;
					list[index] = new KeyValuePair<TKey, TValue>(key, value);
				}
				else
				{
					Add(key, value);
				}
			}
		}

		public ICollection<TKey> Keys => new KeyCollection(this);

		public ICollection<TValue> Values => new ValueCollection(this);

		public int Count => dictionary.Count;

		public bool IsReadOnly => false;

		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 0, 1, 1 })]
		public KeyValuePair<TKey, TValue> this[int index]
		{
			[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 0, 1, 1 })]
			get
			{
				return list[index];
			}
			[param: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 0, 1, 1 })]
			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([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 0, 1, 1 })] KeyValuePair<TKey, TValue> item)
		{
			dictionary.Add(item.Key, item.Value);
			list.Add(item);
		}

		public void Clear()
		{
			dictionary.Clear();
			list.Clear();
		}

		public bool Contains([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 0, 1, 1 })] KeyValuePair<TKey, TValue> item)
		{
			return dictionary.Contains(item);
		}

		public bool ContainsKey(TKey key)
		{
			return dictionary.ContainsKey(key);
		}

		public void CopyTo([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 1, 0, 1, 1 })] KeyValuePair<TKey, TValue>[] array, int arrayIndex)
		{
			list.CopyTo(array, arrayIndex);
		}

		[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 1, 0, 1, 1 })]
		public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
		{
			return list.GetEnumerator();
		}

		public void Insert(int index, TKey key, TValue value)
		{
			dictionary.Add(key, value);
			list.Insert(index, new KeyValuePair<TKey, TValue>(key, value));
		}

		public bool Remove(TKey key)
		{
			if (dictionary.ContainsKey(key))
			{
				int index = list.FindIndex(([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 0, 1, 1 })] KeyValuePair<TKey, TValue> kvp) => comparer.Equals(kvp.Key, key));
				list.RemoveAt(index);
				if (!dictionary.Remove(key))
				{
					throw new InvalidOperationException();
				}
				return true;
			}
			return false;
		}

		public bool Remove([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 0, 1, 1 })] KeyValuePair<TKey, TValue> item)
		{
			return Remove(item.Key);
		}

		public void RemoveAt(int index)
		{
			TKey key = list[index].Key;
			dictionary.Remove(key);
			list.RemoveAt(index);
		}

		public bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value)
		{
			return dictionary.TryGetValue(key, out value);
		}

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

		[OnDeserialized]
		internal void OnDeserializedMethod(StreamingContext context)
		{
			dictionary = new Dictionary<TKey, TValue>();
			foreach (KeyValuePair<TKey, TValue> item in list)
			{
				dictionary[item.Key] = item.Value;
			}
		}
	}
	[DebuggerStepThrough]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	internal static class StringBuilderPool
	{
		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
		internal readonly struct BuilderWrapper : IDisposable
		{
			public readonly StringBuilder Builder;

			private readonly ConcurrentObjectPool<StringBuilder> _pool;

			public BuilderWrapper(StringBuilder builder, ConcurrentObjectPool<StringBuilder> pool)
			{
				Builder = builder;
				_pool = pool;
			}

			public override string ToString()
			{
				return Builder.ToString();
			}

			public void Dispose()
			{
				StringBuilder builder = Builder;
				if (builder.Capacity <= 1024)
				{
					builder.Length = 0;
					_pool.Free(builder);
				}
			}
		}

		private static readonly ConcurrentObjectPool<StringBuilder> Pool;

		static StringBuilderPool()
		{
			Pool = new ConcurrentObjectPool<StringBuilder>(() => new StringBuilder());
		}

		public static BuilderWrapper Rent()
		{
			return new BuilderWrapper(Pool.Allocate(), Pool);
		}
	}
	internal static class ThrowHelper
	{
		[MethodImpl(MethodImplOptions.NoInlining)]
		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		public static void ThrowArgumentOutOfRangeException(string paramName, string message)
		{
			throw new ArgumentOutOfRangeException(paramName, message);
		}
	}
	internal static class Lazy
	{
		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		public static Lazy<T> FromValue<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] T>(T value)
		{
			Lazy<T> lazy = new Lazy<T>(() => value, isThreadSafe: false);
			_ = lazy.Value;
			return lazy;
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal static class ReadOnlyCollectionExtensions
	{
		public static IReadOnlyList<T> AsReadonlyList<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] T>(this List<T> list)
		{
			return list;
		}

		public static IReadOnlyDictionary<TKey, TValue> AsReadonlyDictionary<TKey, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] TValue>(this Dictionary<TKey, TValue> dictionary)
		{
			return dictionary;
		}
	}
}
namespace YamlDotNet.Core
{
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal struct AnchorName : IEquatable<AnchorName>
	{
		public static readonly AnchorName Empty = default(AnchorName);

		private static readonly Regex AnchorPattern = new Regex("^[^\\[\\]\\{\\},]+$", RegexOptions.Compiled);

		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		private readonly string value;

		public string Value => value ?? throw new InvalidOperationException("Cannot read the Value of an empty anchor");

		public bool IsEmpty => value == null;

		public 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);
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
		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);
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
		public static implicit operator AnchorName(string value)
		{
			if (value != null)
			{
				return new AnchorName(value);
			}
			return Empty;
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	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)
		{
		}
	}
	[DebuggerStepThrough]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal sealed class CharacterAnalyzer<TBuffer> where TBuffer : class, ILookAheadBuffer
	{
		public TBuffer Buffer { get; }

		public bool EndOfInput => Buffer.EndOfInput;

		public CharacterAnalyzer(TBuffer buffer)
		{
			Buffer = buffer ?? throw new ArgumentNullException("buffer");
		}

		public char Peek(int offset)
		{
			return Buffer.Peek(offset);
		}

		public void Skip(int length)
		{
			Buffer.Skip(length);
		}

		public bool IsAlphaNumericDashOrUnderscore(int offset = 0)
		{
			char c = Buffer.Peek(offset);
			if ((c < '0' || c > '9') && (c < 'A' || c > 'Z') && (c < 'a' || c > 'z') && c != '_')
			{
				return c == '-';
			}
			return true;
		}

		public bool IsAscii(int offset = 0)
		{
			return Buffer.Peek(offset) <= '\u007f';
		}

		public bool IsPrintable(int offset = 0)
		{
			char c = Buffer.Peek(offset);
			switch (c)
			{
			default:
				if (c != '\u0085' && (c < '\u00a0' || c > '\ud7ff'))
				{
					if (c >= '\ue000')
					{
						return c <= '\ufffd';
					}
					return false;
				}
				break;
			case '\t':
			case '\n':
			case '\r':
			case ' ':
			case '!':
			case '"':
			case '#':
			case '$':
			case '%':
			case '&':
			case '\'':
			case '(':
			case ')':
			case '*':
			case '+':
			case ',':
			case '-':
			case '.':
			case '/':
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
			case ':':
			case ';':
			case '<':
			case '=':
			case '>':
			case '?':
			case '@':
			case 'A':
			case 'B':
			case 'C':
			case 'D':
			case 'E':
			case 'F':
			case 'G':
			case 'H':
			case 'I':
			case 'J':
			case 'K':
			case 'L':
			case 'M':
			case 'N':
			case 'O':
			case 'P':
			case 'Q':
			case 'R':
			case 'S':
			case 'T':
			case 'U':
			case 'V':
			case 'W':
			case 'X':
			case 'Y':
			case 'Z':
			case '[':
			case '\\':
			case ']':
			case '^':
			case '_':
			case '`':
			case 'a':
			case 'b':
			case 'c':
			case 'd':
			case 'e':
			case 'f':
			case 'g':
			case 'h':
			case 'i':
			case 'j':
			case 'k':
			case 'l':
			case 'm':
			case 'n':
			case 'o':
			case 'p':
			case 'q':
			case 'r':
			case 's':
			case 't':
			case 'u':
			case 'v':
			case 'w':
			case 'x':
			case 'y':
			case 'z':
			case '{':
			case '|':
			case '}':
			case '~':
				break;
			}
			return true;
		}

		public bool IsDigit(int offset = 0)
		{
			char c = Buffer.Peek(offset);
			if (c >= '0')
			{
				return c <= '9';
			}
			return false;
		}

		public int AsDigit(int offset = 0)
		{
			return Buffer.Peek(offset) - 48;
		}

		public bool IsHex(int offset)
		{
			char c = Buffer.Peek(offset);
			if ((c < '0' || c > '9') && (c < 'A' || c > 'F'))
			{
				if (c >= 'a')
				{
					return c <= 'f';
				}
				return false;
			}
			return true;
		}

		public int AsHex(int offset)
		{
			char c = Buffer.Peek(offset);
			if (c <= '9')
			{
				return c - 48;
			}
			if (c <= 'F')
			{
				return c - 65 + 10;
			}
			return c - 97 + 10;
		}

		public bool IsSpace(int offset = 0)
		{
			return Check(' ', offset);
		}

		public bool IsZero(int offset = 0)
		{
			return Check('\0', offset);
		}

		public bool IsTab(int offset = 0)
		{
			return Check('\t', offset);
		}

		public bool IsWhite(int offset = 0)
		{
			if (!IsSpace(offset))
			{
				return IsTab(offset);
			}
			return true;
		}

		public bool IsBreak(int offset = 0)
		{
			return Check("\r\n\u0085\u2028\u2029", offset);
		}

		public bool IsCrLf(int offset = 0)
		{
			if (Check('\r', offset))
			{
				return Check('\n', offset + 1);
			}
			return false;
		}

		public bool IsBreakOrZero(int offset = 0)
		{
			if (!IsBreak(offset))
			{
				return IsZero(offset);
			}
			return true;
		}

		public bool IsWhiteBreakOrZero(int offset = 0)
		{
			if (!IsWhite(offset))
			{
				return IsBreakOrZero(offset);
			}
			return true;
		}

		public bool Check(char expected, int offset = 0)
		{
			return Buffer.Peek(offset) == expected;
		}

		public bool Check(string expectedCharacters, int offset = 0)
		{
			char value = Buffer.Peek(offset);
			return expectedCharacters.IndexOf(value) != -1;
		}
	}
	internal static class Constants
	{
		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(1)]
		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;
	}
	[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;
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(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;
			}
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal class Emitter : IEmitter
	{
		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)]
		private class AnchorData
		{
			public AnchorName Anchor;

			public bool IsAlias;
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
		private class TagData
		{
			public string Handle;

			public string Suffix;
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)]
		private class ScalarData
		{
			[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(1)]
			public string Value = string.Empty;

			public bool IsMultiline;

			public bool IsFlowPlainAllowed;

			public bool IsBlockPlainAllowed;

			public bool IsSingleQuotedAllowed;

			public bool IsBlockAllowed;

			public bool HasSingleQuotes;

			public 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;
			using (Queue<ParsingEvent>.Enumerator enumerator = events.GetEnumerator())
			{
				while (enumerator.MoveNext())
				{
					switch (enumerator.Current.Type)
					{
					case EventType.DocumentStart:
					case EventType.SequenceStart:
					case EventType.MappingStart:
						num2++;
						break;
					case EventType.DocumentEnd:
					case EventType.SequenceEnd:
					case EventType.MappingEnd:
						num2--;
						break;
					}
					if (num2 == 0)
					{
						return false;
					}
				}
			}
			return true;
		}

		private void AnalyzeEvent(ParsingEvent evt)
		{
			anchorData.Anchor = AnchorName.Empty;
			tagData.Handle = null;
			tagData.Suffix = null;
			if (evt is YamlDotNet.Core.Events.AnchorAlias anchorAlias)
			{
				AnalyzeAnchor(anchorAlias.Value, isAlias: true);
			}
			else if (evt is NodeEvent nodeEvent)
			{
				if (evt is YamlDotNet.Core.Events.Scalar scalar)
				{
					AnalyzeScalar(scalar);
				}
				AnalyzeAnchor(nodeEvent.Anchor, isAlias: false);
				if (!nodeEvent.Tag.IsEmpty && (isCanonical || nodeEvent.IsCanonical))
				{
					AnalyzeTag(nodeEvent.Tag);
				}
			}
		}

		private void AnalyzeAnchor(AnchorName anchor, bool isAlias)
		{
			anchorData.Anchor = anchor;
			anchorData.IsAlias = isAlias;
		}

		private void AnalyzeScalar(YamlDotNet.Core.Events.Scalar scalar)
		{
			string value = scalar.Value;
			scalarData.Value = value;
			if (value.Length == 0)
			{
				if (scalar.Tag == "tag:yaml.org,2002:null")
				{
					scalarData.IsMultiline = false;
					scalarData.IsFlowPlainAllowed = false;
					scalarData.IsBlockPlainAllowed = true;
					scalarData.IsSingleQuotedAllowed = false;
					scalarData.IsBlockAllowed = false;
				}
				else
				{
					scalarData.IsMultiline = false;
					scalarData.IsFlowPlainAllowed = false;
					scalarData.IsBlockPlainAllowed = false;
					scalarData.IsSingleQuotedAllowed = true;
					scalarData.IsBlockAllowed = false;
				}
				return;
			}
			bool flag = false;
			bool flag2 = false;
			if (value.StartsWith("---", StringComparison.Ordinal) || value.StartsWith("...", StringComparison.Ordinal))
			{
				flag = true;
				flag2 = true;
			}
			CharacterAnalyzer<StringLookAheadBuffer> characterAnalyzer = new CharacterAnalyzer<StringLookAheadBuffer>(new StringLookAheadBuffer(value));
			bool flag3 = true;
			bool flag4 = characterAnalyzer.IsWhiteBreakOrZero(1);
			bool flag5 = false;
			bool flag6 = false;
			bool flag7 = false;
			bool flag8 = false;
			bool flag9 = false;
			bool flag10 = false;
			bool flag11 = false;
			bool flag12 = false;
			bool flag13 = false;
			bool flag14 = false;
			bool flag15 = false;
			bool flag16 = !ValueIsRepresentableInOutputEncoding(value);
			bool flag17 = false;
			bool flag18 = false;
			bool flag19 = true;
			while (!characterAnalyzer.EndOfInput)
			{
				if (flag19)
				{
					if (characterAnalyzer.Check("#,[]{}&*!|>\\\"%@`'"))
					{
						flag = true;
						flag2 = true;
						flag9 = characterAnalyzer.Check('\'');
						flag17 |= characterAnalyzer.Check('\'');
					}
					if (characterAnalyzer.Check("?:"))
					{
						flag = true;
						if (flag4)
						{
							flag2 = true;
						}
					}
					if (characterAnalyzer.Check('-') && flag4)
					{
						flag = true;
						flag2 = true;
					}
				}
				else
				{
					if (characterAnalyzer.Check(",?[]{}"))
					{
						flag = true;
					}
					if (characterAnalyzer.Check(':'))
					{
						flag = true;
						if (flag4)
						{
							flag2 = true;
						}
					}
					if (characterAnalyzer.Check('#') && flag3)
					{
						flag = true;
						flag2 = true;
					}
					flag17 |= characterAnalyzer.Check('\'');
				}
				if (!flag16 && !characterAnalyzer.IsPrintable())
				{
					flag16 = true;
				}
				if (characterAnalyzer.IsBreak())
				{
					flag15 = true;
				}
				if (characterAnalyzer.IsSpace())
				{
					if (flag19)
					{
						flag5 = true;
					}
					if (characterAnalyzer.Buffer.Position >= characterAnalyzer.Buffer.Length - 1)
					{
						flag7 = true;
					}
					if (flag13)
					{
						flag10 = true;
						flag14 = true;
					}
					flag12 = true;
					flag13 = false;
				}
				else if (characterAnalyzer.IsBreak())
				{
					if (flag19)
					{
						flag6 = true;
					}
					if (characterAnalyzer.Buffer.Position >= characterAnalyzer.Buffer.Length - 1)
					{
						flag8 = true;
					}
					if (flag12)
					{
						flag11 = true;
					}
					if (flag14)
					{
						flag18 = true;
					}
					flag12 = false;
					flag13 = true;
				}
				else
				{
					flag12 = false;
					flag13 = false;
					flag14 = false;
				}
				flag3 = characterAnalyzer.IsWhiteBreakOrZero();
				characterAnalyzer.Skip(1);
				if (!characterAnalyzer.EndOfInput)
				{
					flag4 = characterAnalyzer.IsWhiteBreakOrZero(1);
				}
				flag19 = false;
			}
			scalarData.IsFlowPlainAllowed = true;
			scalarData.IsBlockPlainAllowed = true;
			scalarData.IsSingleQuotedAllowed = true;
			scalarData.IsBlockAllowed = true;
			if (flag5 || flag6 || flag7 || flag8 || flag9)
			{
				scalarData.IsFlowPlainAllowed = false;
				scalarData.IsBlockPlainAllowed = false;
			}
			if (flag7)
			{
				scalarData.IsBlockAllowed = false;
			}
			if (flag10)
			{
				scalarData.IsFlowPlainAllowed = false;
				scalarData.IsBlockPlainAllowed = false;
				scalarData.IsSingleQuotedAllowed = false;
			}
			if (flag11 || flag16)
			{
				scalarData.IsFlowPlainAllowed = false;
				scalarData.IsBlockPlainAllowed = false;
				scalarData.IsSingleQuotedAllowed = false;
			}
			if (flag18)
			{
				scalarData.IsBlockAllowed = false;
			}
			scalarData.IsMultiline = flag15;
			if (flag15)
			{
				scalarData.IsFlowPlainAllowed = false;
				scalarData.IsBlockPlainAllowed = false;
			}
			if (flag)
			{
				scalarData.IsFlowPlainAllowed = false;
			}
			if (flag2)
			{
				scalarData.IsBlockPlainAllowed = false;
			}
			scalarData.HasSingleQuotes = flag17;
		}

		private bool ValueIsRepresentableInOutputEncoding(string value)
		{
			if (outputUsesUnicodeEncoding)
			{
				return true;
			}
			try
			{
				byte[] bytes = output.Encoding.GetBytes(value);
				return output.Encoding.GetString(bytes, 0, bytes.Length).Equals(value);
			}
			catch (EncoderFallbackException)
			{
				return false;
			}
			catch (ArgumentOutOfRangeException)
			{
				return false;
			}
		}

		private bool IsUnicode(Encoding encoding)
		{
			if (!(encoding is UTF8Encoding) && !(encoding is UnicodeEncoding))
			{
				return encoding is UTF7Encoding;
			}
			return true;
		}

		private void AnalyzeTag(TagName tag)
		{
			tagData.Handle = tag.Value;
			foreach (TagDirective tagDirective in tagDirectives)
			{
				if (tag.Value.StartsWith(tagDirective.Prefix, StringComparison.Ordinal))
				{
					tagData.Handle = tagDirective.Handle;
					tagData.Suffix = tag.Value.Substring(tagDirective.Prefix.Length);
					break;
				}
			}
		}

		private void StateMachine(ParsingEvent evt)
		{
			if (evt is YamlDotNet.Core.Events.Comment comment)
			{
				EmitComment(comment);
				return;
			}
			switch (state)
			{
			case EmitterState.StreamStart:
				EmitStreamStart(evt);
				break;
			case EmitterState.FirstDocumentStart:
				EmitDocumentStart(evt, isFirst: true);
				break;
			case EmitterState.DocumentStart:
				EmitDocumentStart(evt, isFirst: false);
				break;
			case EmitterState.DocumentContent:
				EmitDocumentContent(evt);
				break;
			case EmitterState.DocumentEnd:
				EmitDocumentEnd(evt);
				break;
			case EmitterState.FlowSequenceFirstItem:
				EmitFlowSequenceItem(evt, isFirst: true);
				break;
			case EmitterState.FlowSequenceItem:
				EmitFlowSequenceItem(evt, isFirst: false);
				break;
			case EmitterState.FlowMappingFirstKey:
				EmitFlowMappingKey(evt, isFirst: true);
				break;
			case EmitterState.FlowMappingKey:
				EmitFlowMappingKey(evt, isFirst: false);
				break;
			case EmitterState.FlowMappingSimpleValue:
				EmitFlowMappingValue(evt, isSimple: true);
				break;
			case EmitterState.FlowMappingValue:
				EmitFlowMappingValue(evt, isSimple: false);
				break;
			case EmitterState.BlockSequenceFirstItem:
				EmitBlockSequenceItem(evt, isFirst: true);
				break;
			case EmitterState.BlockSequenceItem:
				EmitBlockSequenceItem(evt, isFirst: false);
				break;
			case EmitterState.BlockMappingFirstKey:
				EmitBlockMappingKey(evt, isFirst: true);
				break;
			case EmitterState.BlockMappingKey:
				EmitBlockMappingKey(evt, isFirst: false);
				break;
			case EmitterState.BlockMappingSimpleValue:
				EmitBlockMappingValue(evt, isSimple: true);
				break;
			case EmitterState.BlockMappingValue:
				EmitBlockMappingValue(evt, isSimple: false);
				break;
			case EmitterState.StreamEnd:
				throw new YamlException("Expected nothing after STREAM-END");
			default:
				throw new InvalidOperationException();
			}
		}

		private void EmitComment(YamlDotNet.Core.Events.Comment comment)
		{
			if (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([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 2, 1 })] 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);
			}
			else
			{
				WriteIndicator("?", needWhitespace: true, whitespace: false, indentation: true);
				states.Push(EmitterState.BlockMappingValue);
				EmitNode(evt, isMapping: true, isSimpleKey: false);
			}
		}

		private void EmitBlockMappingValue(ParsingEvent evt, bool isSimple)
		{
			if (isSimple)
			{
				WriteIndicator(":", needWhitespace: false, whitespace: false, indentation: false);
			}
			else
			{
				WriteIndent();
				WriteIndicator(":", needWhitespace: true, whitespace: false, indentation: true);
			}
			states.Push(EmitterState.BlockMappingKey);
			EmitNode(evt, isMapping: true, isSimpleKey: false);
		}

		private void IncreaseIndent(bool isFlow, bool isIndentless)
		{
			indents.Push(indent);
			if (indent < 0)
			{
				indent = (isFlow ? bestIndent : 0);
			}
			else if (!isIndentless || !forceIndentLess)
			{
				indent += bestIndent;
			}
		}

		private bool CheckEmptyDocument()
		{
			int num = 0;
			foreach (ParsingEvent @event in events)
			{
				num++;
				if (num == 2)
				{
					if (@event is YamlDotNet.Core.Events.Scalar scalar)
					{
						return string.IsNullOrEmpty(scalar.Value);
					}
					break;
				}
			}
			return false;
		}

		private bool CheckSimpleKey()
		{
			if (events.Count < 1)
			{
				return false;
			}
			int num;
			switch (events.Peek().Type)
			{
			case EventType.Alias:
				num = AnchorNameLength(anchorData.Anchor);
				break;
			case EventType.Scalar:
				if (scalarData.IsMultiline)
				{
					return false;
				}
				num = AnchorNameLength(anchorData.Anchor) + SafeStringLength(tagData.Handle) + SafeStringLength(tagData.Suffix) + SafeStringLength(scalarData.Value);
				break;
			case EventType.SequenceStart:
				if (!CheckEmptySequence())
				{
					return false;
				}
				num = AnchorNameLength(anchorData.Anchor) + SafeStringLength(tagData.Handle) + SafeStringLength(tagData.Suffix);
				break;
			case EventType.MappingStart:
				if (!CheckEmptySequence())
				{
					return false;
				}
				num = AnchorNameLength(anchorData.Anchor) + SafeStringLength(tagData.Handle) + SafeStringLength(tagData.Suffix);
				break;
			default:
				return false;
			}
			return num <= maxSimpleKeyLength;
		}

		private int AnchorNameLength(AnchorName value)
		{
			if (!value.IsEmpty)
			{
				return value.Value.Length;
			}
			return 0;
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
		private int SafeStringLength(string value)
		{
			return value?.Length ?? 0;
		}

		private bool CheckEmptySequence()
		{
			return CheckEmptyStructure<SequenceStart, SequenceEnd>();
		}

		private bool CheckEmptyMapping()
		{
			return CheckEmptyStructure<MappingStart, MappingEnd>();
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)]
		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, [<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)] ([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(1)] Match match) =>
			{
				StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
				try
				{
					StringBuilder builder = builderWrapper.Builder;
					byte[] bytes = Encoding.UTF8.GetBytes(match.Value);
					foreach (byte b in bytes)
					{
						builder.AppendFormat("%{0:X02}", b);
					}
					return builder.ToString();
				}
				finally
				{
					((IDisposable)builderWrapper).Dispose();
				}
			});
		}

		private void Write(char value)
		{
			output.Write(value);
			column++;
		}

		private void Write(string value)
		{
			output.Write(value);
			column += value.Length;
		}

		private void WriteBreak(char breakCharacter = '\n')
		{
			if (breakCharacter == '\n')
			{
				output.Write(newLine);
			}
			else
			{
				output.Write(breakCharacter);
			}
			column = 0;
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	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()
		{
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
		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);
		}
	}
	internal enum EmitterState
	{
		StreamStart,
		StreamEnd,
		FirstDocumentStart,
		DocumentStart,
		DocumentContent,
		DocumentEnd,
		FlowSequenceFirstItem,
		FlowSequenceItem,
		FlowMappingFirstKey,
		FlowMappingKey,
		FlowMappingSimpleValue,
		FlowMappingValue,
		BlockSequenceFirstItem,
		BlockSequenceItem,
		BlockMappingFirstKey,
		BlockMappingKey,
		BlockMappingSimpleValue,
		BlockMappingValue
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	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)
		{
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
	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;
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal interface IEmitter
	{
		void Emit(ParsingEvent @event);
	}
	internal interface ILookAheadBuffer
	{
		bool EndOfInput { get; }

		char Peek(int offset);

		void Skip(int length);
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	internal sealed class InsertionQueue<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] T> : IEnumerable<T>, IEnumerable
	{
		private const int DefaultInitialCapacity = 128;

		private T[] items;

		private int readPtr;

		private int writePtr;

		private int mask;

		private int count;

		public int Count => count;

		public int Capacity => items.Length;

		public 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();
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
	internal interface IParser
	{
		ParsingEvent Current { get; }

		bool MoveNext();
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
	internal interface IScanner
	{
		Mark CurrentPosition { get; }

		Token Current { get; }

		bool MoveNext();

		bool MoveNextWithoutConsuming();

		void ConsumeCurrent();
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[DebuggerStepThrough]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	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;
		}
	}
	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;
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		public override string ToString()
		{
			return $"Line: {Line}, Col: {Column}, Idx: {Index}";
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
		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()));
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
		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;
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	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)
		{
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	internal sealed class MergingParser : IParser
	{
		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
		private sealed class ParsingEventCollection : IEnumerable<LinkedListNode<ParsingEvent>>, IEnumerable
		{
			private readonly LinkedList<ParsingEvent> events;

			private readonly HashSet<LinkedListNode<ParsingEvent>> deleted;

			private readonly Dictionary<AnchorName, LinkedListNode<ParsingEvent>> references;

			public ParsingEventCollection()
			{
				events = new LinkedList<ParsingEvent>();
				deleted = new HashSet<LinkedListNode<ParsingEvent>>();
				references = new Dictionary<AnchorName, LinkedListNode<ParsingEvent>>();
			}

			public void AddAfter(LinkedListNode<ParsingEvent> node, IEnumerable<ParsingEvent> items)
			{
				foreach (ParsingEvent item in items)
				{
					node = events.AddAfter(node, item);
				}
			}

			public void Add(ParsingEvent item)
			{
				LinkedListNode<ParsingEvent> node = events.AddLast(item);
				AddReference(item, node);
			}

			public void MarkDeleted(LinkedListNode<ParsingEvent> node)
			{
				deleted.Add(node);
			}

			public void CleanMarked()
			{
				foreach (LinkedListNode<ParsingEvent> item in deleted)
				{
					events.Remove(item);
				}
			}

			public IEnumerable<LinkedListNode<ParsingEvent>> FromAnchor(AnchorName anchor)
			{
				LinkedListNode<ParsingEvent> next = references[anchor].Next;
				return Enumerate(next);
			}

			public IEnumerator<LinkedListNode<ParsingEvent>> GetEnumerator()
			{
				return Enumerate(events.First).GetEnumerator();
			}

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

			private IEnumerable<LinkedListNode<ParsingEvent>> Enumerate([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 2, 1 })] LinkedListNode<ParsingEvent> node)
			{
				while (node != null)
				{
					yield return node;
					node = node.Next;
				}
			}

			private void AddReference(ParsingEvent item, LinkedListNode<ParsingEvent> node)
			{
				if (item is MappingStart mappingStart)
				{
					AnchorName anchor = mappingStart.Anchor;
					if (!anchor.IsEmpty)
					{
						references[anchor] = node;
					}
				}
			}
		}

		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
		private sealed class ParsingEventCloner : IParsingEventVisitor
		{
			[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
			private ParsingEvent clonedEvent;

			public ParsingEvent Clone(ParsingEvent e)
			{
				e.Accept(this);
				if (clonedEvent == null)
				{
					throw new InvalidOperationException($"Could not clone event of type '{e.Type}'");
				}
				return clonedEvent;
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.AnchorAlias e)
			{
				clonedEvent = new YamlDotNet.Core.Events.AnchorAlias(e.Value, e.Start, e.End);
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.StreamStart e)
			{
				throw new NotSupportedException();
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.StreamEnd e)
			{
				throw new NotSupportedException();
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.DocumentStart e)
			{
				throw new NotSupportedException();
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.DocumentEnd e)
			{
				throw new NotSupportedException();
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.Scalar e)
			{
				clonedEvent = new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, e.Tag, e.Value, e.Style, e.IsPlainImplicit, e.IsQuotedImplicit, e.Start, e.End);
			}

			void IParsingEventVisitor.Visit(SequenceStart e)
			{
				clonedEvent = new SequenceStart(AnchorName.Empty, e.Tag, e.IsImplicit, e.Style, e.Start, e.End);
			}

			void IParsingEventVisitor.Visit(SequenceEnd e)
			{
				Mark start = e.Start;
				Mark end = e.End;
				clonedEvent = new SequenceEnd(in start, in 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)
			{
				Mark start = e.Start;
				Mark end = e.End;
				clonedEvent = new MappingEnd(in start, in end);
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.Comment e)
			{
				throw new NotSupportedException();
			}
		}

		private readonly ParsingEventCollection events;

		private readonly IParser innerParser;

		private IEnumerator<LinkedListNode<ParsingEvent>> iterator;

		private bool merged;

		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		public ParsingEvent Current
		{
			[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
			get
			{
				return 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))
					{
						Mark start = @event.Value.Start;
						Mark end = @event.Value.End;
						throw new SemanticErrorException(in start, in end, "Unrecognized merge key pattern");
					}
				}
			}
		}

		private bool HandleMerge([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 2, 1 })] LinkedListNode<ParsingEvent> node)
		{
			if (node == null)
			{
				return false;
			}
			if (node.Value is YamlDotNet.Core.Events.AnchorAlias anchorAlias)
			{
				return HandleAnchorAlias(node, node, anchorAlias);
			}
			if (node.Value is SequenceStart)
			{
				return HandleSequence(node);
			}
			return false;
		}

		private bool HandleMergeSequence(LinkedListNode<ParsingEvent> sequenceStart, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 2, 1 })] LinkedListNode<ParsingEvent> node)
		{
			if (node == null)
			{
				return false;
			}
			if (node.Value is YamlDotNet.Core.Events.AnchorAlias anchorAlias)
			{
				return HandleAnchorAlias(sequenceStart, node, anchorAlias);
			}
			if (node.Value is SequenceStart)
			{
				return HandleSequence(node);
			}
			return false;
		}

		private bool IsMergeToken(LinkedListNode<ParsingEvent> node)
		{
			if (node.Value is YamlDotNet.Core.Events.Scalar scalar)
			{
				return scalar.Value == "<<";
			}
			return false;
		}

		private bool HandleAnchorAlias(LinkedListNode<ParsingEvent> node, LinkedListNode<ParsingEvent> anchorNode, YamlDotNet.Core.Events.AnchorAlias anchorAlias)
		{
			IEnumerable<ParsingEvent> mappingEvents = GetMappingEvents(anchorAlias.Value);
			events.AddAfter(node, mappingEvents);
			events.MarkDeleted(anchorNode);
			return true;
		}

		private bool HandleSequence(LinkedListNode<ParsingEvent> node)
		{
			events.MarkDeleted(node);
			LinkedListNode<ParsingEvent> linkedListNode = node;
			while (linkedListNode != null)
			{
				if (linkedListNode.Value is SequenceEnd && linkedListNode.Value.Start.Line >= node.Value.Start.Line)
				{
					events.MarkDeleted(linkedListNode);
					return true;
				}
				LinkedListNode<ParsingEvent> next = linkedListNode.Next;
				HandleMergeSequence(node, next);
				linkedListNode = next;
			}
			return true;
		}

		private IEnumerable<ParsingEvent> GetMappingEvents(AnchorName anchor)
		{
			ParsingEventCloner cloner = new ParsingEventCloner();
			int nesting = 0;
			return from e in (from e in events.FromAnchor(anchor)
					select e.Value).TakeWhile([<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(0)] (ParsingEvent e) => (nesting += e.NestingIncrease) >= 0)
				select cloner.Clone(e);
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	internal class Parser : IParser
	{
		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
		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;

		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		private Token currentToken;

		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		private VersionDirective version;

		private readonly EventQueue pendingEvents = new EventQueue();

		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		[field: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		public ParsingEvent Current
		{
			[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
			get;
			[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
			private set;
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
		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();
			Mark start;
			Mark end;
			if (!(token is YamlDotNet.Core.Tokens.StreamStart streamStart))
			{
				start = token?.Start ?? Mark.Empty;
				end = token?.End ?? Mark.Empty;
				throw new SemanticErrorException(in start, in end, "Did not find expected <stream-start>.");
			}
			Skip();
			state = ParserState.ImplicitDocumentStart;
			start = streamStart.Start;
			end = streamStart.End;
			return new YamlDotNet.Core.Events.StreamStart(in start, in 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);
			}
			Mark start2;
			Mark 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))
				{
					start2 = token.Start;
					end = token.End;
					throw new SemanticErrorException(in start2, in end, "Did not find expected <document start>.");
				}
				states.Push(ParserState.DocumentEnd);
				state = ParserState.DocumentContent;
				Mark end2 = token.End;
				Skip();
				return new YamlDotNet.Core.Events.DocumentStart(versionDirective, tags2, isImplicit: false, start, end2);
			}
			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");
			start2 = token.Start;
			end = token.End;
			YamlDotNet.Core.Events.StreamEnd result = new YamlDotNet.Core.Events.StreamEnd(in start2, in end);
			if (scanner.MoveNextWithoutConsuming())
			{
				throw new InvalidOperationException("The scanner should contain no more tokens.");
			}
			return result;
		}

		[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		private VersionDirective ProcessDirectives(TagDirectiveCollection tags)
		{
			bool flag = false;
			VersionDirective result = null;
			while (true)
			{
				if (GetCurrentToken() is VersionDirective versionDirective)
				{
					if (version != null)
					{
						Mark start = versionDirective.Start;
						Mark end = versionDirective.End;
						throw new SemanticErrorException(in start, in end, "Found duplicate %YAML directive.");
					}
					if (versionDirective.Version.Major != 1 || versionDirective.Version.Minor > 3)
					{
						Mark start = versionDirective.Start;
						Mark end = versionDirective.End;
						throw new SemanticErrorException(in start, in end, "Found incompatible YAML document.");
					}
					result = (version = versionDirective);
					flag = true;
				}
				else
				{
					if (!(GetCurrentToken() is TagDirective tagDirective))
					{
						break;
					}
					if (tags.Contains(tagDirective.Handle))
					{
						Mark start = tagDirective.Start;
						Mark end = tagDirective.End;
						throw new SemanticErrorException(in start, in 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();
				Mark position = scanner.CurrentPosition;
				return ProcessEmptyScalar(in position);
			}
			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)
		{
			Mark start;
			Mark end;
			if (GetCurrentToken() is Error error)
			{
				start = error.Start;
				end = error.End;
				throw new SemanticErrorException(in start, in 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 anchor4)
						{
							start = anchor4.Start;
							end = anchor4.End;
							throw new SemanticErrorException(in start, in end, "While parsing a node, found more than one anchor.");
						}
						if (token is YamlDotNet.Core.Tokens.AnchorAlias anchorAlias2)
						{
							start = anchorAlias2.Start;
							end = anchorAlias2.End;
							throw new SemanticErrorException(in start, in 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);
						}
						start = error2.Start;
						end = error2.End;
						throw new SemanticErrorException(in start, in end, error2.Value);
					}
					tag2 = tag3;
					if (string.IsNullOrEmpty(tag3.Handle))
					{
						tag = new TagName(tag3.Suffix);
					}
					else
					{
						if (!tagDirectives.Contains(tag3.Handle))
						{
							start = tag3.Start;
							end = tag3.End;
							throw new SemanticErrorException(in start, in 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;
						start = error3.Start;
						end = error3.End;
						throw new SemanticErrorException(in start, in end, error3.Value);
					}
				}
				if (state == ParserState.FlowMappingKey && scanner.MoveNextWithoutConsuming())
				{
					currentToken = scanner.Current;
					if (currentToken != null && !(currentToken is FlowEntry) && !(currentToken is FlowMappingEnd))
					{
						start = currentToken.Start;
						end = currentToken.End;
						throw new SemanticErrorException(in start, in 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);
			}
			start = token.Start;
			end = token.End;
			throw new SemanticErrorException(in start, in 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 blockEntry)
			{
				Mark position = blockEntry.End;
				Skip();
				token = GetCurrentToken();
				if (!(token is BlockEntry) && !(token is BlockEnd))
				{
					states.Push(ParserState.BlockSequenceEntry);
					return ParseNode(isBlock: true, isIndentlessSequence: false);
				}
				state = ParserState.BlockSequenceEntry;
				return ProcessEmptyScalar(in position);
			}
			Mark start;
			Mark end;
			if (token is BlockEnd blockEnd)
			{
				state = states.Pop();
				start = blockEnd.Start;
				end = blockEnd.End;
				SequenceEnd result = new SequenceEnd(in start, in end);
				Skip();
				return result;
			}
			start = token?.Start ?? Mark.Empty;
			end = token?.End ?? Mark.Empty;
			throw new SemanticErrorException(in start, in end, "While parsing a block collection, did not find expected '-' indicator.");
		}

		private ParsingEvent ParseIndentlessSequenceEntry()
		{
			Token token = GetCurrentToken();
			if (token is BlockEntry blockEntry)
			{
				Mark position = blockEntry.End;
				Skip();
				token = GetCurrentToken();
				if (!(token is BlockEntry) && !(token is Key) && !(token is Value) && !(token is BlockEnd))
				{
					states.Push(ParserState.IndentlessSequenceEntry);
					return ParseNode(isBlock: true, isIndentlessSequence: false);
				}
				state = ParserState.IndentlessSequenceEntry;
				return ProcessEmptyScalar(in position);
			}
			state = states.Pop();
			Mark start = token?.Start ?? Mark.Empty;
			Mark end = token?.End ?? Mark.Empty;
			return new SequenceEnd(in start, in end);
		}

		private ParsingEvent ParseBlockMappingKey(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			Token token = GetCurrentToken();
			if (token is Key key)
			{
				Mark position = key.End;
				Skip();
				token = GetCurrentToken();
				if (!(token is Key) && !(token is Value) && !(token is BlockEnd))
				{
					states.Push(ParserState.BlockMappingValue);
					return ParseNode(isBlock: true, isIndentlessSequence: true);
				}
				state = ParserState.BlockMappingValue;
				return ProcessEmptyScalar(in position);
			}
			Mark position2;
			if (token is Value value)
			{
				Skip();
				position2 = value.End;
				return ProcessEmptyScalar(in position2);
			}
			if (token is YamlDotNet.Core.Tokens.AnchorAlias anchorAlias)
			{
				Skip();
				return new YamlDotNet.Core.Events.AnchorAlias(anchorAlias.Value, anchorAlias.Start, anchorAlias.End);
			}
			Mark end;
			if (token is BlockEnd blockEnd)
			{
				state = states.Pop();
				position2 = blockEnd.Start;
				end = blockEnd.End;
				MappingEnd result = new MappingEnd(in position2, in end);
				Skip();
				return result;
			}
			if (GetCurrentToken() is Error error)
			{
				position2 = error.Start;
				end = error.End;
				throw new SyntaxErrorException(in position2, in end, error.Value);
			}
			position2 = token?.Start ?? Mark.Empty;
			end = token?.End ?? Mark.Empty;
			throw new SemanticErrorException(in position2, in end, "While parsing a block mapping, did not find expected key.");
		}

		private ParsingEvent ParseBlockMappingValue()
		{
			Token token = GetCurrentToken();
			if (token is Value value)
			{
				Mark position = value.End;
				Skip();
				token = GetCurrentToken();
				if (!(token is Key) && !(token is Value) && !(token is BlockEnd))
				{
					states.Push(ParserState.BlockMappingKey);
					return ParseNode(isBlock: true, isIndentlessSequence: true);
				}
				state = ParserState.BlockMappingKey;
				return ProcessEmptyScalar(in position);
			}
			Mark start;
			if (token is Error error)
			{
				start = error.Start;
				Mark end = error.End;
				throw new SemanticErrorException(in start, in end, error.Value);
			}
			state = ParserState.BlockMappingKey;
			start = token?.Start ?? Mark.Empty;
			return ProcessEmptyScalar(in start);
		}

		private ParsingEvent ParseFlowSequenceEntry(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			Token token = GetCurrentToken();
			Mark start;
			Mark end;
			if (!(token is FlowSequenceEnd))
			{
				if (!isFirst)
				{
					if (!(token is FlowEntry))
					{
						start = token?.Start ?? Mark.Empty;
						end = token?.End ?? Mark.Empty;
						throw new SemanticErrorException(in start, in end, "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();
			start = token?.Start ?? Mark.Empty;
			end = token?.End ?? Mark.Empty;
			SequenceEnd result2 = new SequenceEnd(in start, in end);
			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;
			Mark position = token?.Start ?? Mark.Empty;
			return ProcessEmptyScalar(in position);
		}

		private ParsingEvent ParseFlowSequenceEntryMappingEnd()
		{
			state = ParserState.FlowSequenceEntry;
			Token token = GetCurrentToken();
			Mark start = token?.Start ?? Mark.Empty;
			Mark end = token?.End ?? Mark.Empty;
			return new MappingEnd(in start, in end);
		}

		private ParsingEvent ParseFlowMappingKey(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			Token token = GetCurrentToken();
			Mark start;
			Mark end;
			if (!(token is FlowMappingEnd))
			{
				if (!isFirst)
				{
					if (token is FlowEntry)
					{
						Skip();
						token = GetCurrentToken();
					}
					else if (!(token is YamlDotNet.Core.Tokens.Scalar))
					{
						start = token?.Start ?? Mark.Empty;
						end = token?.End ?? Mark.Empty;
						throw new SemanticErrorException(in start, in end, "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;
					start = token?.Start ?? Mark.Empty;
					return ProcessEmptyScalar(in start);
				}
				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();
			start = token?.Start ?? Mark.Empty;
			end = token?.End ?? Mark.Empty;
			return new MappingEnd(in start, in end);
		}

		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);
			}
			Mark position = token?.Start ?? Mark.Empty;
			return ProcessEmptyScalar(in position);
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal static class ParserExtensions
	{
		public static T Consume<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] T>(this IParser parser) where T : ParsingEvent
		{
			T result = parser.Require<T>();
			parser.MoveNext();
			return result;
		}

		public static bool TryConsume<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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.");
				}
				Mark start = current.Start;
				Mark end = current.End;
				throw new YamlException(in start, in end, $"Expected '{typeof(T).Name}', got '{current.GetType().Name}' (at {current.Start}).");
			}
			return @event;
		}

		public static bool Accept<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] T>(this IParser parser) where T : ParsingEvent
		{
			return parser.Consume<T>();
		}

		[Obsolete("Please use TryConsume<T>(out var evt) instead")]
		[return: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		[return: MaybeNull]
		public static T Allow<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		[return: MaybeNull]
		public static T Peek<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] 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<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)] T>(this IParser parser) where T : ParsingEvent
		{
			T @event;
			return parser.Accept<T>(out @event);
		}

		public static bool TryFindMappingEntry(this IParser parser, Func<YamlDotNet.Core.Events.Scalar, bool> selector, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)][MaybeNullWhen(false)] out YamlDotNet.Core.Events.Scalar key, [MaybeNullWhen(false)][<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] out ParsingEvent value)
		{
			if (parser.TryConsume<MappingStart>(out var _))
			{
				while (parser.Current != null)
				{
					ParsingEvent current = parser.Current;
					if (!(current is YamlDotNet.Core.Events.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;
		}
	}
	internal enum ParserState
	{
		StreamStart,
		StreamEnd,
		ImplicitDocumentStart,
		DocumentStart,
		DocumentContent,
		DocumentEnd,
		BlockNode,
		BlockNodeOrIndentlessSequence,
		FlowNode,
		BlockSequenceFirstEntry,
		BlockSequenceEntry,
		IndentlessSequenceEntry,
		BlockMappingFirstKey,
		BlockMappingKey,
		BlockMappingValue,
		FlowSequenceFirstEntry,
		FlowSequenceEntry,
		FlowSequenceEntryMappingKey,
		FlowSequenceEntryMappingValue,
		FlowSequenceEntryMappingEnd,
		FlowMappingFirstKey,
		FlowMappingKey,
		FlowMappingValue,
		FlowMappingEmptyValue
	}
	internal sealed class RecursionLevel
	{
		private int current;

		public int Maximum { get; }

		public RecursionLevel(int maximum)
		{
			Maximum = maximum;
		}

		public void Increment()
		{
			if (!TryIncrement())
			{
				throw new MaximumRecursionLevelReachedException("Maximum level of recursion reached");
			}
		}

		public bool TryIncrement()
		{
			if (current < Maximum)
			{
				current++;
				return true;
			}
			return false;
		}

		public void Decrement()
		{
			if (current == 0)
			{
				throw new InvalidOperationException("Attempted to decrement RecursionLevel to a negative value");
			}
			current--;
		}
	}
	internal enum ScalarStyle
	{
		Any,
		Plain,
		SingleQuoted,
		DoubleQuoted,
		Literal,
		Folded
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	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;

		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		private Token previous;

		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		private Anchor previousAnchor;

		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		private YamlDotNet.Core.Tokens.Scalar lastScalar;

		private static readonly byte[] EmptyBytes = new byte[0];

		public bool SkipComments { get; private set; }

		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		[field: <c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		public Token Current
		{
			[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
			get;
			[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
			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('\''))
			{
				FetchFlowScalar(isSingleQuoted: true);
			}
			else if (analyzer.Check('"'))
			{
				FetchFlowScalar(isSingleQuoted: false);
			}
			else if ((!analyzer.IsWhiteBreakOrZero() && !analyzer.Check("-?:,[]{}#&*!|>'\"%@`")) || (analyzer.Check('-') && !analyzer.IsWhite(1)) || (analyzer.Check("?:") && !analyzer.IsWhiteBreakOrZero(1)) || (simpleKeyAllowed && flowLevel > 0))
			{
				if (plainScalarFollowedByComment)
				{
					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();
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(in start, in end, "While scanning for the next token, found character that cannot start any token.");
				}
				Skip();
			}
		}

		private bool CheckWhiteSpace()
		{
			if (!analyzer.Check(' '))
			{
				if (flowLevel > 0 || !simpleKeyAllowed)
				{
					return analyzer.Check('\t');
				}
				return false;
			}
			return true;
		}

		private void Skip()
		{
			cursor.Skip();
			analyzer.Buffer.Skip(1);
		}

		private void SkipLine()
		{
			if (analyzer.IsCrLf())
			{
				cursor.SkipLineByOffset(2);
				analyzer.Buffer.Skip(2);
			}
			else if (analyzer.IsBreak())
			{
				cursor.SkipLineByOffset(1);
				analyzer.Buffer.Skip(1);
			}
			else if (!analyzer.IsZero())
			{
				throw new InvalidOperationException("Not at a break.");
			}
		}

		private void ScanToNextToken()
		{
			while (true)
			{
				if (CheckWhiteSpace())
				{
					Skip();
					continue;
				}
				ProcessComment();
				if (analyzer.IsBreak())
				{
					SkipLine();
					if (flowLevel == 0)
					{
						simpleKeyAllowed = true;
					}
					continue;
				}
				break;
			}
		}

		private void ProcessComment()
		{
			if (!analyzer.Check('#'))
			{
				return;
			}
			Mark start = cursor.Mark();
			Skip();
			while (analyzer.IsSpace())
			{
				Skip();
			}
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				while (!analyzer.IsBreakOrZero())
				{
					builder.Append(ReadCurrentCharacter());
				}
				if (!SkipComments)
				{
					bool isInline = previous != null && previous.End.Line == start.Line && previous.End.Column != 1 && !(previous is YamlDotNet.Core.Tokens.StreamStart);
					tokens.Enqueue(new YamlDotNet.Core.Tokens.Comment(builder.ToString(), isInline, start, cursor.Mark()));
				}
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private void FetchStreamStart()
		{
			simpleKeys.Push(new SimpleKey());
			simpleKeyAllowed = true;
			streamStartProduced = true;
			Mark start = cursor.Mark();
			tokens.Enqueue(new YamlDotNet.Core.Tokens.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 YamlDotNet.Core.Tokens.StreamEnd(in start, in start));
		}

		private void FetchDirective()
		{
			UnrollIndent(-1);
			RemoveSimpleKey();
			simpleKeyAllowed = false;
			Token token = ScanDirective();
			if (token != null)
			{
				tokens.Enqueue(token);
			}
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
		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 YamlDotNet.Core.Tokens.DocumentStart) && !(previous is YamlDotNet.Core.Tokens.StreamStart) && !(previous is YamlDotNet.Core.Tokens.DocumentEnd))
				{
					Mark end = cursor.Mark();
					throw new SemanticErrorException(in start, in end, "While scanning a version directive, did not find preceding <document end>.");
				}
				result = ScanVersionDirectiveValue(in start);
			}
			while (analyzer.IsWhite())
			{
				Skip();
			}
			ProcessComment();
			if (!analyzer.IsBreakOrZero())
			{
				Mark end = cursor.Mark();
				throw new SyntaxErrorException(in start, in end, "While scanning a directive, did not find expected comment or line break.");
			}
			if (analyzer.IsBreak())
			{
				SkipLine();
			}
			return result;
		}

		private void FetchDocumentIndicator(bool isStartToken)
		{
			UnrollIndent(-1);
			RemoveSimpleKey();
			simpleKeyAllowed = false;
			Mark end = cursor.Mark();
			Skip();
			Skip();
			Skip();
			if (isStartToken)
			{
				InsertionQueue<Token> insertionQueue = tokens;
				Mark end2 = cursor.Mark();
				insertionQueue.Enqueue(new YamlDotNet.Core.Tokens.DocumentStart(in end, in end2));
				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.", end, cursor.Mark());
					break;
				}
				Skip();
			}
			tokens.Enqueue(new YamlDotNet.Core.Tokens.DocumentEnd(in end, in end));
			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()
		{
			Mark start;
			if (flowLevel == 0)
			{
				if (!simpleKeyAllowed)
				{
					if (previousAnchor != null && previousAnchor.End.Line == cursor.Line)
					{
						start = previousAnchor.Start;
						Mark end = previousAnchor.End;
						throw new SemanticErrorException(in start, in 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 start2 = cursor.Mark();
			Skip();
			InsertionQueue<Token> insertionQueue = tokens;
			start = cursor.Mark();
			insertionQueue.Enqueue(new BlockEntry(in start2, in start));
		}

		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();
			InsertionQueue<Token> insertionQueue = tokens;
			Mark end = cursor.Mark();
			insertionQueue.Enqueue(new Key(in start2, in end));
		}

		private void FetchValue()
		{
			SimpleKey simpleKey = simpleKeys.Peek();
			Mark start;
			if (simpleKey.IsPossible)
			{
				InsertionQueue<Token> insertionQueue = tokens;
				int index = simpleKey.TokenNumber - tokensParsed;
				start = simpleKey.Mark;
				Mark end = simpleKey.Mark;
				insertionQueue.Insert(index, new Key(in start, in end));
				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)
					{
						InsertionQueue<Token> insertionQueue2 = tokens;
						int count = tokens.Count;
						start = simpleKey.Mark;
						Mark end = simpleKey.Mark;
						insertionQueue2.Insert(count, new Key(in start, in end));
						flag = false;
					}
				}
				simpleKeyAllowed = flag;
			}
			Mark start2 = cursor.Mark();
			Skip();
			InsertionQueue<Token> insertionQueue3 = tokens;
			start = cursor.Mark();
			insertionQueue3.Enqueue(new Value(in start2, in start));
		}

		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("?:,]}%@`")))
				{
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(in start, in end, "While scanning an anchor or alias, found value containing disallowed: []{},");
				}
				AnchorName value = new AnchorName(builder.ToString());
				if (isAlias)
				{
					return new YamlDotNet.Core.Tokens.AnchorAlias(value, start, cursor.Mark());
				}
				return previousAnchor = new Anchor(value, start, cursor.Mark());
			}
			finally
			{
				((IDisposable)builderWrapper).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('>'))
				{
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(in start, in end, "While scanning a tag, did not find the expected '>'.");
				}
				Skip();
			}
			else
			{
				string text3 = ScanTagHandle(isDirective: false, start);
				if (text3.Length > 1 && text3[0] == '!' && text3[text3.Length - 1] == '!')
				{
					text = text3;
					text2 = ScanTagUri(null, start);
				}
				else
				{
					text2 = ScanTagUri(text3, start);
					text = "!";
					if (text2.Length == 0)
					{
						text2 = text;
						text = string.Empty;
					}
				}
			}
			if (!analyzer.IsWhiteBreakOrZero() && !analyzer.Check(','))
			{
				Mark end = cursor.Mark();
				throw new SyntaxErrorException(in start, in end, "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'))
								{
									Mark end = cursor.Mark();
									throw new SyntaxErrorException(in start, in end, "While scanning a block scalar, found an indentation indicator equal to 0.");
								}
								num2 = analyzer.AsDigit();
								Skip();
							}
						}
						else if (analyzer.IsDigit())
						{
							if (analyzer.Check('0'))
							{
								Mark end = cursor.Mark();
								throw new SyntaxErrorException(in start, in end, "While scanning a block scalar, found an indentation indicator equal to 0.");
							}
							num2 = analyzer.AsDigit();
							Skip();
							if (analyzer.Check("+-"))
							{
								num = (analyzer.Check('+') ? 1 : (-1));
								Skip();
							}
						}
						if (analyzer.Check('#'))
						{
							Mark end = cursor.Mark();
							throw new SyntaxErrorException(in start, in end, "While scanning a block scalar, found a comment without whtespace after '>' indicator.");
						}
						while (analyzer.IsWhite())
						{
							Skip();
						}
						ProcessComment();
						if (!analyzer.IsBreakOrZero())
						{
							Mark end = cursor.Mark();
							throw new SyntaxErrorException(in start, in end, "While scanning a block scalar, did not find expected comment or line break.");
						}
						if (analyzer.IsBreak())
						{
							SkipLine();
							if (!isFirstLine.HasValue)
							{
								isFirstLine = true;
							}
							else if (isFirstLine == true)
							{
								isFirstLine = false;
							}
						}
						Mark end2 = cursor.Mark();
						if (num2 != 0)
						{
							currentIndent = ((indent >= 0) ? (indent + num2) : num2);
						}
						currentIndent = ScanBlockScalarBreaks(currentIndent, builder3, isLiteral, ref end2, ref isFirstLine);
						isFirstLine = false;
						while (cursor.LineOffset == currentIndent && !analyzer.IsZero() && !IsDocumentEnd())
						{
							bool flag2 = analyzer.IsWhite();
							if (!isLiteral && StartsWith(builder2, '\n') && !flag && !flag2)
							{
								if (builder3.Length == 0)
								{
									builder.Append(' ');
								}
								builder2.Length = 0;
							}
							else
							{
								builder.Append(builder2.ToString());
								builder2.Length = 0;
							}
							builder.Append(builder3.ToString());
							builder3.Length = 0;
							flag = analyzer.IsWhite();
							while (!analyzer.IsBreakOrZero())
							{
								builder.Append(ReadCurrentCharacter());
							}
							char c = ReadLine();
							if (c != 0)
							{
								builder2.Append(c);
							}
							currentIndent = ScanBlockScalarBreaks(currentIndent, builder3, isLiteral, ref end2, ref isFirstLine);
						}
						if (num != -1)
						{
							builder.Append((object?)builder2);
						}
						if (num == 1)
						{
							builder.Append((object?)builder3);
						}
						ScalarStyle style = (isLiteral ? ScalarStyle.Literal : ScalarStyle.Folded);
						return new YamlDotNet.Core.Tokens.Scalar(builder.ToString(), style, start, end2);
					}
					finally
					{
						((IDisposable)builderWrapper3).Dispose();
					}
				}
				finally
				{
					((IDisposable)builderWrapper2).Dispose();
				}
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private int ScanBlockScalarBreaks(int currentIndent, StringBuilder breaks, bool isLiteral, ref 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)
			{
				Mark end2 = cursor.Mark();
				throw new SemanticErrorException(in end, in end2, "While scanning a literal block scalar, found extra spaces in first line.");
			}
			if (!isLiteral && num > cursor.LineOffset && num2 > -1)
			{
				Mark end2 = cursor.Mark();
				throw new SemanticErrorException(in end, in end2, "While scanning a literal block scalar, found more spaces in lines above first content line.");
			}
			if (currentIndent == 0 && (cursor.LineOffset > 0 || indent > -1))
			{
				currentIndent = Math.Max(num, Math.Max(indent + 1, 1));
			}
			return currentIndent;
		}

		private void FetchFlowScalar(bool isSingleQuoted)
		{
			SaveSimpleKey();
			simpleKeyAllowed = false;
			flowScalarFetched = true;
			tokens.Enqueue(ScanFlowScalar(isSingleQuoted));
			if (!isSingleQuoted && analyzer.Check('#'))
			{
				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())
								{
									Mark end = cursor.Mark();
									throw new SyntaxErrorException(in start, in end, "While scanning a quoted scalar, found unexpected document indicator.");
								}
								if (analyzer.IsZero())
								{
									Mark end = cursor.Mark();
									throw new SyntaxErrorException(in start, in end, "While scanning a quoted scalar, found unexpected end of stream.");
								}
								if (flag && !isSingleQuoted && indent >= cursor.LineOffset)
								{
									Mark end = cursor.Mark();
									throw new SyntaxErrorException(in start, in end, "While scanning a multi-line double-quoted scalar, found wrong indentation.");
								}
								flag = false;
								while (!analyzer.IsWhiteBreakOrZero())
								{
									if (isSingleQuoted && analyzer.Check('\'') && analyzer.Check('\'', 1))
									{
										builder.Append('\'');
										Skip();
										Skip();
										continue;
									}
									if (analyzer.Check(isSingleQuoted ? '\'' : '"'))
									{
										break;
									}
									if (!isSingleQuoted && analyzer.Check('\\') && analyzer.IsBreak(1))
									{
										Skip();
										SkipLine();
										flag = true;
										break;
									}
									if (!isSingleQuoted && analyzer.Check('\\'))
									{
										int num = 0;
										char c = analyzer.Peek(1);
										switch (c)
										{
										case 'x':
											num = 2;
											break;
										case 'u':
											num = 4;
											break;
										case 'U':
											num = 8;
											break;
										default:
										{
											if (SimpleEscapeCodes.TryGetValue(c, out var value))
											{
												builder.Append(value);
												break;
											}
											Mark end = cursor.Mark();
											throw new SyntaxErrorException(in start, in end, "While scanning a quoted scalar, found unknown escape character.");
										}
										}
										Skip();
										Skip();
										if (num <= 0)
										{
											continue;
										}
										int num2 = 0;
										for (int i = 0; i < num; i++)
										{
											if (!analyzer.IsHex(i))
											{
												Mark end = cursor.Mark();
												throw new SyntaxErrorException(in start, in end, "While scanning a quoted scalar, did not find expected hexadecimal number.");
											}
											num2 = (num2 << 4) + analyzer.AsHex(i);
										}
										if ((num2 >= 55296 && num2 <= 57343) || num2 > 1114111)
										{
											Mark end = cursor.Mark();
											throw new SyntaxErrorException(in start, in end, "While scanning a quoted scalar, found invalid Unicode character escape code.");
										}
										builder.Append(char.ConvertFromUtf32(num2));
										for (int j = 0; j < num; j++)
										{
											Skip();
										}
									}
									else
									{
										builder.Append(ReadCurrentCharacter());
									}
								}
								if (analyzer.Check(isSingleQuoted ? '\'' : '"'))
								{
									break;
								}
								while (analyzer.IsWhite() || analyzer.IsBreak())
								{
									if (analyzer.IsWhite())
									{
										if (!flag)
										{
											builder2.Append(ReadCurrentCharacter());
										}
										else
										{
											Skip();
										}
									}
									else if (!flag)
									{
										builder2.Length = 0;
										builder3.Append(ReadLine());
										flag = true;
									}
									else
									{
										builder4.Append(ReadLine());
									}
								}
								if (flag)
								{
									if (StartsWith(builder3, '\n'))
									{
										if (builder4.Length == 0)
										{
											builder.Append(' ');
										}
										else
										{
											builder.Append(builder4.ToString());
										}
									}
									else
									{
										builder.Append(builder3.ToString());
										builder.Append(builder4.ToString());
									}
									builder3.Length = 0;
									builder4.Length = 0;
								}
								else
								{
									builder.Append(builder2.ToString());
									builder2.Length = 0;
								}
							}
							Skip();
							return new YamlDotNet.Core.Tokens.Scalar(builder.ToString(), isSingleQuoted ? ScalarStyle.SingleQuoted : ScalarStyle.DoubleQuoted, start, cursor.Mark());
						}
						finally
						{
							((IDisposable)builderWrapper4).Dispose();
						}
					}
					finally
					{
						((IDisposable)builderWrapper3).Dispose();
					}
				}
				finally
				{
					((IDisposable)builderWrapper2).Dispose();
				}
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private void FetchPlainScalar()
		{
			SaveSimpleKey();
			simpleKeyAllowed = false;
			bool isMultiline = false;
			YamlDotNet.Core.Tokens.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 YamlDotNet.Core.Tokens.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())
										{
											Mark end2 = cursor.Mark();
											throw new SyntaxErrorException(in start, in end2, "While scanning a plain scalar, found a tab character that violate indentation.");
										}
										if (!flag)
										{
											builder2.Append(ReadCurrentCharacter());
										}
										else
										{
											Skip();
										}
									}
									else
									{
										isMultiline = true;
										if (!flag)
										{
											builder2.Length = 0;
											builder3.Append(ReadLine());
											flag = true;
										}
										else
										{
											builder4.Append(ReadLine());
										}
									}
								}
								if (flowLevel == 0 && cursor.LineOffset < num)
								{
									break;
								}
							}
							if (flag)
							{
								simpleKeyAllowed = true;
							}
							return new YamlDotNet.Core.Tokens.Scalar(builder.ToString(), ScalarStyle.Plain, start, end);
						}
						finally
						{
							((IDisposable)builderWrapper4).Dispose();
						}
					}
					finally
					{
						((IDisposable)builderWrapper3).Dispose();
					}
				}
				finally
				{
					((IDisposable)builderWrapper2).Dispose();
				}
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private void RemoveSimpleKey()
		{
			SimpleKey simpleKey = simpleKeys.Peek();
			if (simpleKey.IsPossible && simpleKey.IsRequired)
			{
				Mark start = simpleKey.Mark;
				Mark end = simpleKey.Mark;
				throw new SyntaxErrorException(in start, in end, "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)
				{
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(in start, in end, "While scanning a directive, could not find expected directive name.");
				}
				if (analyzer.EndOfInput)
				{
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(in start, in end, "While scanning a directive, found unexpected end of stream.");
				}
				if (!analyzer.IsWhiteBreakOrZero())
				{
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(in start, in end, "While scanning a directive, found unexpected non-alphabetical character.");
				}
				return builder.ToString();
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private void SkipWhitespaces()
		{
			while (analyzer.IsWhite())
			{
				Skip();
			}
		}

		private Token ScanVersionDirectiveValue(in Mark start)
		{
			SkipWhitespaces();
			int major = ScanVersionDirectiveNumber(in start);
			if (!analyzer.Check('.'))
			{
				Mark end = cursor.Mark();
				throw new SyntaxErrorException(in start, in end, "While scanning a %YAML directive, did not find expected digit or '.' character.");
			}
			Skip();
			int minor = ScanVersionDirectiveNumber(in start);
			return new VersionDirective(new Version(major, minor), start, start);
		}

		private Token ScanTagDirectiveValue(in Mark start)
		{
			SkipWhitespaces();
			string handle = ScanTagHandle(isDirective: true, start);
			if (!analyzer.IsWhite())
			{
				Mark end = cursor.Mark();
				throw new SyntaxErrorException(in start, in end, "While scanning a %TAG directive, did not find expected whitespace.");
			}
			SkipWhitespaces();
			string prefix = ScanTagUri(null, start);
			if (!analyzer.IsWhiteBreakOrZero())
			{
				Mark end = cursor.Mark();
				throw new SyntaxErrorException(in start, in end, "While scanning a %TAG directive, did not find expected whitespace or line break.");
			}
			return new TagDirective(handle, prefix, start, start);
		}

		private string ScanTagUri([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] 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(","))
				{
					Mark start2 = cursor.Mark();
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(in start2, in end, "Unexpected comma at end of tag");
				}
				return text;
			}
			finally
			{
				((IDisposable)builderWrapper).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))
				{
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(in start, in end, "While scanning a tag, did not find URI escaped octet.");
				}
				int num2 = (analyzer.AsHex(1) << 4) + analyzer.AsHex(2);
				if (num == 0)
				{
					num = (((num2 & 0x80) == 0) ? 1 : (((num2 & 0xE0) == 192) ? 2 : (((num2 & 0xF0) == 224) ? 3 : (((num2 & 0xF8) == 240) ? 4 : 0))));
					if (num == 0)
					{
						Mark end = cursor.Mark();
						throw new SyntaxErrorException(in start, in end, "While scanning a tag, found an incorrect leading UTF-8 octet.");
					}
					array = new byte[num];
				}
				else if ((num2 & 0xC0) != 128)
				{
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(in start, in end, "While scanning a tag, found an incorrect trailing UTF-8 octet.");
				}
				array[count++] = (byte)num2;
				Skip();
				Skip();
				Skip();
			}
			while (--num > 0);
			string @string = Encoding.UTF8.GetString(array, 0, count);
			if (@string.Length == 0 || @string.Length > 2)
			{
				Mark end = cursor.Mark();
				throw new SyntaxErrorException(in start, in end, "While scanning a tag, found an incorrect UTF-8 sequence.");
			}
			return @string;
		}

		private string ScanTagHandle(bool isDirective, Mark start)
		{
			if (!analyzer.Check('!'))
			{
				Mark end = cursor.Mark();
				throw new SyntaxErrorException(in start, in end, "While scanning a tag, did not find expected '!'.");
			}
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				builder.Append(ReadCurrentCharacter());
				while (analyzer.IsAlphaNumericDashOrUnderscore())
				{
					builder.Append(ReadCurrentCharacter());
				}
				if (analyzer.Check('!'))
				{
					builder.Append(ReadCurrentCharacter());
				}
				else if (isDirective && (builder.Length != 1 || builder[0] != '!'))
				{
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(in start, in end, "While scanning a tag directive, did not find expected '!'.");
				}
				return builder.ToString();
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private int ScanVersionDirectiveNumber(in Mark start)
		{
			int num = 0;
			int num2 = 0;
			while (analyzer.IsDigit())
			{
				if (++num2 > 9)
				{
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(in start, in end, "While scanning a %YAML directive, found extremely long version number.");
				}
				num = num * 10 + analyzer.AsDigit();
				Skip();
			}
			if (num2 == 0)
			{
				Mark end = cursor.Mark();
				throw new SyntaxErrorException(in start, in end, "While scanning a %YAML directive, did not find expected version number.");
			}
			return num;
		}

		private void SaveSimpleKey()
		{
			bool isRequired = flowLevel == 0 && indent == cursor.LineOffset;
			if (simpleKeyAllowed)
			{
				SimpleKey item = new SimpleKey(isRequired, tokensParsed + tokens.Count, cursor);
				RemoveSimpleKey();
				simpleKeys.Pop();
				simpleKeys.Push(item);
			}
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	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)
		{
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal sealed class SimpleKey
	{
		private readonly Cursor cursor;

		public bool IsPossible { get; private set; }

		public bool IsRequired { get; }

		public int TokenNumber { get; }

		public int Index => cursor.Index;

		public int Line => cursor.Line;

		public int LineOffset => cursor.LineOffset;

		public Mark Mark => cursor.Mark();

		public void MarkAsImpossible()
		{
			IsPossible = false;
		}

		public SimpleKey()
		{
			cursor = new Cursor();
		}

		public SimpleKey(bool isRequired, int tokenNumber, Cursor cursor)
		{
			IsPossible = true;
			IsRequired = isRequired;
			TokenNumber = tokenNumber;
			this.cursor = new Cursor(cursor);
		}
	}
	internal sealed class StringLookAheadBuffer : ILookAheadBuffer
	{
		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(1)]
		private readonly string value;

		public int Position { get; private set; }

		public int Length => value.Length;

		public bool EndOfInput => IsOutside(Position);

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		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;
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	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)
		{
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 0, 1, 1 })]
	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));
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal readonly struct TagName : IEquatable<TagName>
	{
		public static readonly TagName Empty;

		[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)]
		private readonly string value;

		public string Value => value ?? throw new InvalidOperationException("Cannot read the Value of a non-specific tag");

		public bool IsEmpty => value == null;

		public bool IsNonSpecific
		{
			get
			{
				if (!IsEmpty)
				{
					if (!(value == "!"))
					{
						return value == "?";
					}
					return true;
				}
				return false;
			}
		}

		public bool IsLocal
		{
			get
			{
				if (!IsEmpty)
				{
					return Value[0] == '!';
				}
				return false;
			}
		}

		public bool IsGlobal
		{
			get
			{
				if (!IsEmpty)
				{
					return !IsLocal;
				}
				return false;
			}
		}

		public 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);
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
		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);
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
		public static implicit operator TagName(string value)
		{
			if (value != null)
			{
				return new TagName(value);
			}
			return Empty;
		}
	}
	internal sealed class Version
	{
		public int Major { get; }

		public int Minor { get; }

		public Version(int major, int minor)
		{
			if (major < 0)
			{
				throw new ArgumentOutOfRangeException("major", $"{major} should be >= 0");
			}
			Major = major;
			if (minor < 0)
			{
				throw new ArgumentOutOfRangeException("minor", $"{minor} should be >= 0");
			}
			Minor = minor;
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
		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());
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	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, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] 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}";
		}
	}
}
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;
		}
	}
	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;
		}
	}
	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)
		{
		}
	}
	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)
		{
		}
	}
	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)
		{
		}
	}
	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)
		{
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	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;
		}
	}
	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)
		{
		}
	}
	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)
		{
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal class Error : Token
	{
		public string Value { get; }

		public Error(string value, Mark start, Mark end)
			: base(in start, in end)
		{
			Value = value;
		}
	}
	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)
		{
		}
	}
	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)
		{
		}
	}
	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)
		{
		}
	}
	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)
		{
		}
	}
	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)
		{
		}
	}
	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)
		{
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	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;
		}
	}
	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)
		{
		}
	}
	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)
		{
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	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");
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	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;
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
		public override bool Equals(object obj)
		{
			if (obj is TagDirective tagDirective && Handle.Equals(tagDirective.Handle))
			{
				return Prefix.Equals(tagDirective.Prefix);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return Handle.GetHashCode() ^ Prefix.GetHashCode();
		}

		public override string ToString()
		{
			return Handle + " => " + Prefix;
		}
	}
	internal abstract class Token
	{
		public Mark Start { get; }

		public Mark End { get; }

		protected Token(in Mark start, in Mark end)
		{
			Start = start;
			End = end;
		}
	}
	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)
		{
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	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;
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
		public override bool Equals(object obj)
		{
			if (obj is VersionDirective versionDirective)
			{
				return Version.Equals(versionDirective.Version);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return Version.GetHashCode();
		}
	}
}
namespace YamlDotNet.Core.Events
{
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	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);
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	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 + "]";
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	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);
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(2)]
	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)
		{
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		public override string ToString()
		{
			return $"Document start [isImplicit = {IsImplicit}]";
		}

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal enum EventType
	{
		None,
		StreamStart,
		StreamEnd,
		DocumentStart,
		DocumentEnd,
		Alias,
		Scalar,
		SequenceStart,
		SequenceEnd,
		MappingStart,
		MappingEnd,
		Comment
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	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);
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	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);
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	internal sealed class MappingStart : NodeEvent
	{
		public override int NestingIncrease => 1;

		internal override EventType Type => EventType.MappingStart;

		public bool IsImplicit { get; }

		public override bool IsCanonical => !IsImplicit;

		public MappingStyle Style { get; }

		public MappingStart(AnchorName anchor, TagName tag, bool isImplicit, MappingStyle style, Mark start, Mark end)
			: base(anchor, tag, start, end)
		{
			IsImplicit = isImplicit;
			Style = style;
		}

		public MappingStart(AnchorName anchor, TagName tag, bool isImplicit, MappingStyle style)
			: this(anchor, tag, isImplicit, style, Mark.Empty, Mark.Empty)
		{
		}

		public MappingStart()
			: this(AnchorName.Empty, TagName.Empty, isImplicit: true, MappingStyle.Any, Mark.Empty, Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Mapping start [anchor = {base.Anchor}, tag = {base.Tag}, isImplicit = {IsImplicit}, style = {Style}]";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal enum MappingStyle
	{
		Any,
		Block,
		Flow
	}
	internal abstract class NodeEvent : ParsingEvent
	{
		public AnchorName Anchor { get; }

		public TagName Tag { get; }

		public abstract bool IsCanonical { get; }

		protected NodeEvent(AnchorName anchor, TagName tag, Mark start, Mark end)
			: base(in start, in end)
		{
			Anchor = anchor;
			Tag = tag;
		}

		protected NodeEvent(AnchorName anchor, TagName tag)
			: this(anchor, tag, Mark.Empty, Mark.Empty)
		{
		}
	}
	internal abstract class ParsingEvent
	{
		public virtual int NestingIncrease => 0;

		internal abstract EventType Type { get; }

		public Mark Start { get; }

		public Mark End { get; }

		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		public abstract void Accept(IParsingEventVisitor visitor);

		internal ParsingEvent(in Mark start, in Mark end)
		{
			Start = start;
			End = end;
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	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);
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	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);
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal sealed class SequenceStart : NodeEvent
	{
		public override int NestingIncrease => 1;

		internal override EventType Type => EventType.SequenceStart;

		public bool IsImplicit { get; }

		public override bool IsCanonical => !IsImplicit;

		public SequenceStyle Style { get; }

		public SequenceStart(AnchorName anchor, TagName tag, bool isImplicit, SequenceStyle style, Mark start, Mark end)
			: base(anchor, tag, start, end)
		{
			IsImplicit = isImplicit;
			Style = style;
		}

		public SequenceStart(AnchorName anchor, TagName tag, bool isImplicit, SequenceStyle style)
			: this(anchor, tag, isImplicit, style, Mark.Empty, Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Sequence start [anchor = {base.Anchor}, tag = {base.Tag}, isImplicit = {IsImplicit}, style = {Style}]";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal enum SequenceStyle
	{
		Any,
		Block,
		Flow
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	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);
		}
	}
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	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);
		}
	}
}
namespace System.Collections.Generic
{
	internal static class DeconstructionExtensions
	{
		[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
		public static void Deconstruct<[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] TKey, [<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(2)] TValue>([<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(new byte[] { 0, 1, 1 })] this KeyValuePair<TKey, TValue> pair, out TKey key, out TValue value)
		{
			key = pair.Key;
			value = pair.Value;
		}
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class AllowNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class DisallowNullAttribute : Attribute
	{
	}
	[DebuggerNonUserCode]
	[ExcludeFromCodeCoverage]
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	internal sealed class DoesNotReturnAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[DebuggerNonUserCode]
	[ExcludeFromCodeCoverage]
	internal sealed class DoesNotReturnIfAttribute : Attribute
	{
		public bool ParameterValue { get; }

		public DoesNotReturnIfAttribute(bool parameterValue)
		{
			ParameterValue = parameterValue;
		}
	}
	[DebuggerNonUserCode]
	[ExcludeFromCodeCoverage]
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	internal sealed class MaybeNullAttribute : Attribute
	{
	}
	[DebuggerNonUserCode]
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class MaybeNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public MaybeNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	[DebuggerNonUserCode]
	internal sealed class MemberNotNullAttribute : Attribute
	{
		public string[] Members { get; }

		public MemberNotNullAttribute(string member)
		{
			Members = new string[1] { member };
		}

		public MemberNotNullAttribute(params string[] members)
		{
			Members = members;
		}
	}
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[DebuggerNonUserCode]
	[ExcludeFromCodeCoverage]
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal sealed class MemberNotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public string[] Members { get; }

		public MemberNotNullWhenAttribute(bool returnValue, string member)
		{
			ReturnValue = returnValue;
			Members = new string[1] { member };
		}

		public MemberNotNullWhenAttribute(bool returnValue, params string[] members)
		{
			ReturnValue = returnValue;
			Members = members;
		}
	}
	[DebuggerNonUserCode]
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class NotNullAttribute : Attribute
	{
	}
	[DebuggerNonUserCode]
	[ExcludeFromCodeCoverage]
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Parameter | AttributeTargets.ReturnValue, AllowMultiple = true, Inherited = false)]
	[<c3a1ab49-3f5d-41bb-83da-450d3d8c484a>Nullable(0)]
	[<ab9c2856-5f6a-492d-a076-7480f73ec7af>NullableContext(1)]
	internal sealed class NotNullIfNotNullAttribute : Attribute
	{
		public string ParameterName { get; }

		public NotNullIfNotNullAttribute(string parameterName)
		{
			ParameterName = parameterName;
		}
	}
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	internal sealed class NotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public NotNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	[Microsoft.CodeAnalysis.Embedded]
	[CompilerGenerated]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace AzuExtendedPlayerInventory
{
	[PublicAPI]
	internal class API
	{
		public delegate void SlotAddedHandler(string slotName);

		public delegate void SlotRemovedHandler(string slotName);

		private static readonly Dictionary<SlotAddedHandler, AzuEPI.API.SlotAddedHandler> _slotAddedMap = new Dictionary<SlotAddedHandler, AzuEPI.API.SlotAddedHandler>();

		private static readonly Dictionary<SlotRemovedHandler, AzuEPI.API.SlotRemovedHandler> _slotRemovedMap = new Dictionary<SlotRemovedHandler, AzuEPI.API.SlotRemovedHandler>();

		private static readonly Dictionary<Action<Hud>, Action<Hud>> _hudAwakeMap = new Dictionary<Action<Hud>, Action<Hud>>();

		private static readonly Dictionary<Action<Hud>, Action<Hud>> _hudAwakeCompleteMap = new Dictionary<Action<Hud>, Action<Hud>>();

		private static readonly Dictionary<Action<Hud>, Action<Hud>> _hudUpdateMap = new Dictionary<Action<Hud>, Action<Hud>>();

		private static readonly Dictionary<Action<Hud>, Action<Hud>> _hudUpdateCompleteMap = new Dictionary<Action<Hud>, Action<Hud>>();

		public static event SlotAddedHandler? SlotAdded
		{
			add
			{
				SlotAddedHandler value2 = value;
				if (value2 == null || _slotAddedMap.ContainsKey(value2))
				{
					return;
				}
				AzuEPI.API.SlotAddedHandler value3 = delegate(string s)
				{
					try
					{
						value2(s);
					}
					catch
					{
					}
				};
				_slotAddedMap[value2] = value3;
				AzuEPI.API.SlotAdded += value3;
			}
			remove
			{
				if (value != null && _slotAddedMap.TryGetValue(value, out AzuEPI.API.SlotAddedHandler value2))
				{
					AzuEPI.API.SlotAdded -= value2;
					_slotAddedMap.Remove(value);
				}
			}
		}

		public static event SlotRemovedHandler? SlotRemoved
		{
			add
			{
				SlotRemovedHandler value2 = value;
				if (value2 == null || _slotRemovedMap.ContainsKey(value2))
				{
					return;
				}
				AzuEPI.API.SlotRemovedHandler value3 = delegate(string s)
				{
					try
					{
						value2(s);
					}
					catch
					{
					}
				};
				_slotRemovedMap[value2] = value3;
				AzuEPI.API.SlotRemoved += value3;
			}
			remove
			{
				if (value != null && _slotRemovedMap.TryGetValue(value, out AzuEPI.API.SlotRemovedHandler value2))
				{
					AzuEPI.API.SlotRemoved -= value2;
					_slotRemovedMap.Remove(value);
				}
			}
		}

		public static event Action<Hud>? OnHudAwake
		{
			add
			{
				AddHudEvent(value, _hudAwakeMap, delegate(Action<Hud> h)
				{
					AzuEPI.API.OnHudAwake += h;
				});
			}
			remove
			{
				RemoveHudEvent(value, _hudAwakeMap, delegate(Action<Hud> h)
				{
					AzuEPI.API.OnHudAwake -= h;
				});
			}
		}

		public static event Action<Hud>? OnHudAwakeComplete
		{
			add
			{
				AddHudEvent(value, _hudAwakeCompleteMap, delegate(Action<Hud> h)
				{
					AzuEPI.API.OnHudAwakeComplete += h;
				});
			}
			remove
			{
				RemoveHudEvent(value, _hudAwakeCompleteMap, delegate(Action<Hud> h)
				{
					AzuEPI.API.OnHudAwakeComplete -= h;
				});
			}
		}

		public static event Action<Hud>? OnHudUpdate
		{
			add
			{
				AddHudEvent(value, _hudUpdateMap, delegate(Action<Hud> h)
				{
					AzuEPI.API.OnHudUpdate += h;
				});
			}
			remove
			{
				RemoveHudEvent(value, _hudUpdateMap, delegate(Action<Hud> h)
				{
					AzuEPI.API.OnHudUpdate -= h;
				});
			}
		}

		public static event Action<Hud>? OnHudUpdateComplete
		{
			add
			{
				AddHudEvent(value, _hudUpdateCompleteMap, delegate(Action<Hud> h)
				{
					AzuEPI.API.OnHudUpdateComplete += h;
				});
			}
			remove
			{
				RemoveHudEvent(value, _hudUpdateCompleteMap, delegate(Action<Hud> h)
				{
					AzuEPI.API.OnHudUpdateComplete -= h;
				});
			}
		}

		private static void AddHudEvent(Action<Hud>? handler, Dictionary<Action<Hud>, Action<Hud>> map, Action<Action<Hud>> subscribe)
		{
			Action<Hud> handler2 = handler;
			if (handler2 == null || map.ContainsKey(handler2))
			{
				return;
			}
			Action<Hud> value = delegate(Hud h)
			{
				try
				{
					handler2(h);
				}
				catch
				{
				}
			};
			map[handler2] = value;
		}

		private static void RemoveHudEvent(Action<Hud>? handler, Dictionary<Action<Hud>, Action<Hud>> map, Action<Action<Hud>> unsubscribe)
		{
			if (handler != null && map.TryGetValue(handler, out Action<Hud> _))
			{
				map.Remove(handler);
			}
		}

		public static bool IsLoaded()
		{
			return AzuEPI.API.IsLoaded();
		}

		public static bool AddSlot(string slotName, Func<Player, ItemData?> getItem, Func<ItemData, bool> isValid, int index = -1)
		{
			return false;
		}

		public static bool RemoveSlot(string slotName)
		{
			return AzuEPI.API.RemoveSlot(slotName);
		}

		public static SlotInfo GetSlots()
		{
			AzuEPI.SlotInfo slots = AzuEPI.API.GetSlots();
			return new SlotInfo
			{
				SlotNames = (slots.SlotNames ?? Array.Empty<string>()),
				SlotPositions = (slots.SlotPositions ?? Array.Empty<Vector2>()),
				GetItemFuncs = (slots.GetItemFuncs ?? Array.Empty<Func<Player, ItemData>>()),
				IsValidFuncs = (slots.IsValidFuncs ?? Array.Empty<Func<ItemData, bool>>())
			};
		}

		public static SlotInfo GetQuickSlots()
		{
			AzuEPI.SlotInfo quickSlots = AzuEPI.API.GetQuickSlots();
			return new SlotInfo
			{
				SlotNames = (quickSlots.SlotNames ?? Array.Empty<string>()),
				SlotPositions = (quickSlots.SlotPositions ?? Array.Empty<Vector2>()),
				GetItemFuncs = (quickSlots.GetItemFuncs ?? Array.Empty<Func<Player, ItemData>>()),
				IsValidFuncs = (quickSlots.IsValidFuncs ?? Array.Empty<Func<ItemData, bool>>())
			};
		}

		public static List<ItemData> GetQuickSlotsItems()
		{
			return AzuEPI.API.GetQuickSlotsItems();
		}

		public static int GetAddedRows(int width)
		{
			return AzuEPI.API.GetAddedRows(width);
		}

		public static void HudAwake(Hud h)
		{
		}

		public static void HudAwakeComplete(Hud h)
		{
		}

		public static void HudUpdate(Hud h)
		{
		}

		public static void HudUpdateComplete(Hud h)
		{
		}

		private static void SafeInvoke(Action a)
		{
			try
			{
				a();
			}
			catch
			{
			}
		}
	}
	[PublicAPI]
	internal class SlotInfo
	{
		public string[] SlotNames { get; set; } = Array.Empty<string>();


		public Vector2[] SlotPositions { get; set; } = Array.Empty<Vector2>();


		public Func<Player, ItemData?>?[] GetItemFuncs { get; set; } = Array.Empty<Func<Player, ItemData>>();


		public Func<ItemData, bool>?[] IsValidFuncs { get; set; } = Array.Empty<Func<ItemData, bool>>();

	}
}
namespace AzuEPI
{
	[PublicAPI]
	internal class API
	{
		public delegate void SlotAddedHandler(string slotName);

		public delegate void SlotRemovedHandler(string slotName);

		[CompilerGenerated]
		private sealed class <EnumerateSlots>d__57 : IEnumerable<SlotDescriptor>, IEnumerable, IEnumerator<SlotDescriptor>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private SlotDescriptor <>2__current;

			private int <>l__initialThreadId;

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

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

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

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

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<SlotDescriptor> IEnumerable<SlotDescriptor>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <EnumerateSlots>d__57(0);
			}

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

		[CompilerGenerated]
		private sealed class <GetAllSlotSnapshots>d__58 : IEnumerable<SlotSnapshot>, IEnumerable, IEnumerator<SlotSnapshot>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private SlotSnapshot <>2__current;

			private int <>l__initialThreadId;

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

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

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

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

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<SlotSnapshot> IEnumerable<SlotSnapshot>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <GetAllSlotSnapshots>d__58(0);
			}

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

		[CompilerGenerated]
		private sealed class <GetEquipmentSlotSnapshots>d__60 : IEnumerable<SlotSnapshot>, IEnumerable, IEnumerator<SlotSnapshot>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private SlotSnapshot <>2__current;

			private int <>l__initialThreadId;

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

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

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

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

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<SlotSnapshot> IEnumerable<SlotSnapshot>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <GetEquipmentSlotSnapshots>d__60(0);
			}

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

		[CompilerGenerated]
		private sealed class <GetQuickSlotSnapshots>d__59 : IEnumerable<SlotSnapshot>, IEnumerable, IEnumerator<SlotSnapshot>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private SlotSnapshot <>2__current;

			private int <>l__initialThreadId;

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

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

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

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

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<SlotSnapshot> IEnumerable<SlotSnapshot>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <GetQuickSlotSnapshots>d__59(0);
			}

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

		internal static HashSet<Model.EquipmentSlot?> CustomSlots { get; } = new HashSet<Model.EquipmentSlot>();


		public static event Action<Hud>? OnHudAwake;

		public static event Action<Hud>? OnHudAwakeComplete;

		public static event Action<Hud>? OnHudUpdate;

		public static event Action<Hud>? OnHudUpdateComplete;

		public static event Action? OnBeforeQuickSlotsAdded;

		public static event Action? OnQuickSlotsAdded;

		public static event SlotAddedHandler? SlotAdded;

		public static event SlotRemovedHandler? SlotRemoved;

		public static event Action<string>? OnRegisterVisualPrefab;

		public static bool IsLoaded()
		{
			return false;
		}

		public static ItemType GetFakeItemType()
		{
			return (ItemType)0;
		}

		public static bool AddSlot(string slotName, Func<Player, ItemData?> getItem, Func<ItemData, bool> isValid, int index = -1)
		{
			return false;
		}

		public static bool AddSlot(string slotName, string prefabName, int index = -1)
		{
			return false;
		}

		public static bool AddSlot(string slotName, IEnumerable<string> prefabNames, int index = -1)
		{
			return false;
		}

		public static bool AddSlot(string slotName, Func<ItemData, bool> isValid, int index = -1, IEnumerable<string>? prefabNamesForVisuals = null)
		{
			return false;
		}

		public static bool AddQuickSlot(string slotName, bool showName = false, int index = -1)
		{
			return false;
		}

		public static bool RemoveSlot(string slotName)
		{
			return false;
		}

		public static SlotInfo GetSlots()
		{
			return BuildSlotInfo((Model.Slot _) => true);
		}

		public static SlotInfo GetQuickSlots()
		{
			return BuildSlotInfo((Model.Slot s) => s.IsQuickSlot);
		}

		public static SlotInfo GetEquipmentSlots()
		{
			return BuildSlotInfo((Model.Slot s) => !s.IsQuickSlot && s.EquipmentSlot != null);
		}

		private static SlotInfo BuildSlotInfo(Func<Model.Slot, bool> filter)
		{
			return new SlotInfo();
		}

		public static List<ItemData> GetQuickSlotsItems()
		{
			return new List<ItemData>();
		}

		public static int GetAddedRows(int width)
		{
			return 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int GetFullHeight(int width)
		{
			return 0;
		}

		public static void RegisterVisualPrefabs(string slotName, params (string prefabName, string visualName)[] pairs)
		{
		}

		public static int GetSlotCount()
		{
			return 0;
		}

		public static bool TryGetSlotIndexByName(string slotName, out int index, bool allowLocalized = true)
		{
			index = -1;
			return false;
		}

		public static bool TryGetSlotDescriptor(int index, out SlotDescriptor desc)
		{
			desc = default(SlotDescriptor);
			return false;
		}

		public static int GetSlotGridLinearIndex(Inventory inv, int slotIndex)
		{
			return -1;
		}

		public static Vector2i GetSlotGridPos(Inventory inv, int slotIndex)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2i(-1, -1);
		}

		public static bool TryGetSlotIndexAtGridPos(Inventory inv, Vector2i gridPos, out int slotIndex)
		{
			slotIndex = -1;
			return false;
		}

		public static bool IsEquipmentCell(Inventory inv, int x, int y, out int slotIndex)
		{
			slotIndex = -1;
			return false;
		}

		public static bool IsQuickCell(Inventory inv, int x, int y, out int slotIndex)
		{
			slotIndex = -1;
			return false;
		}

		public static bool TryGetSlotSnapshot(Inventory inv, int slotIndex, out SlotSnapshot snapshot)
		{
			snapshot = default(SlotSnapshot);
			return false;
		}

		[IteratorStateMachine(typeof(<EnumerateSlots>d__57))]
		public static IEnumerable<SlotDescriptor> EnumerateSlots()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <EnumerateSlots>d__57(-2);
		}

		[IteratorStateMachine(typeof(<GetAllSlotSnapshots>d__58))]
		public static IEnumerable<SlotSnapshot> GetAllSlotSnapshots(Inventory inv)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetAllSlotSnapshots>d__58(-2);
		}

		[IteratorStateMachine(typeof(<GetQuickSlotSnapshots>d__59))]
		public static IEnumerable<SlotSnapshot> GetQuickSlotSnapshots(Inventory inv)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetQuickSlotSnapshots>d__59(-2);
		}

		[IteratorStateMachine(typeof(<GetEquipmentSlotSnapshots>d__60))]
		public static IEnumerable<SlotSnapshot> GetEquipmentSlotSnapshots(Inventory inv)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetEquipmentSlotSnapshots>d__60(-2);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryGetSlotIndexByItem(Player player, ItemData item, out int slotIndex)
		{
			slotIndex = -1;
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryGetSlotIndexByItem(ItemData item, out int slotIndex)
		{
			slotIndex = -1;
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryGetSlotDescriptorByItem(Player player, ItemData item, out SlotDescriptor desc)
		{
			desc = default(SlotDescriptor);
			return false;
		}

		public static bool SlotValidates(int slotIndex, ItemData item)
		{
			return false;
		}

		public static bool TryGetEquippedItem(int slotIndex, out ItemData? item)
		{
			item = null;
			return false;
		}

		public static bool TryGetSlotDescriptorByName(string slotName, out SlotDescriptor desc, bool allowLocalized = true)
		{
			desc = default(SlotDescriptor);
			if (!TryGetSlotIndexByName(slotName, out var index, allowLocalized))
			{
				return false;
			}
			return TryGetSlotDescriptor(index, out desc);
		}
	}
	[PublicAPI]
	internal class SlotInfo
	{
		public string[] SlotNames { get; set; } = Array.Empty<string>();


		public string[] OriginalSlotNames { get; set; } = Array.Empty<string>();


		public Vector2[] SlotPositions { get; set; } = Array.Empty<Vector2>();


		public Func<Player, ItemData?>?[] GetItemFuncs { get; set; } = Array.Empty<Func<Player, ItemData>>();


		public Func<ItemData, bool>?[] IsValidFuncs { get; set; } = Array.Empty<Func<ItemData, bool>>();

	}
	[PublicAPI]
	internal struct SlotDescriptor
	{
		public int Index { get; }

		public string Name { get; }

		public string OriginalName { get; }

		public bool IsQuickSlot { get; }

		public bool IsEquipmentSlot { get; }

		public bool IsCustom { get; }

		public Vector2 UiPosition { get; }

		public SlotDescriptor(int index, string name, string originalName, bool isQuickSlot, bool isEquipmentSlot, bool isCustom, Vector2 uiPosition)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			Index = index;
			Name = name ?? string.Empty;
			OriginalName = originalName ?? string.Empty;
			IsQuickSlot = isQuickSlot;
			IsEquipmentSlot = isEquipmentSlot;
			IsCustom = isCustom;
			UiPosition = uiPosition;
		}
	}
	[PublicAPI]
	internal struct SlotSnapshot
	{
		public SlotDescriptor Descriptor { get; }

		public bool Occupied { get; }

		public Vector2i GridPos { get; }

		public int LinearGridIndex { get; }

		public SlotSnapshot(SlotDescriptor descriptor, bool occupied, Vector2i gridPos, int linearGridIndex)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			Descriptor = descriptor;
			Occupied = occupied;
			GridPos = gridPos;
			LinearGridIndex = linearGridIndex;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool Validates(ItemData item)
		{
			return API.SlotValidates(Descriptor.Index, item);
		}
	}
}
namespace AzuEPI.Core.Slots
{
	internal class Model
	{
		internal class Slot
		{
			public string Name;

			public string OriginalName;

			public Vector2 Position;

			public bool IsQuickSlot;

			public bool IsAPIAdded;

			public bool Occupied;

			public EquipmentSlot? EquipmentSlot => this as EquipmentSlot;
		}

		internal class EquipmentSlot : Slot
		{
			public Func<Player, ItemData?>? Get;

			public Func<ItemData, bool>? Valid;
		}
	}
}