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

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("Homestead")]
[assembly: AssemblyDescription("Player-facing construction tools, native blueprints, blueprint trading, build camera controls, placement helpers, and Dvergr circlet QoL for Valheim.")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("sighsorry")]
[assembly: AssemblyProduct("Homestead")]
[assembly: AssemblyCopyright("Copyright 2026 sighsorry")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("4358610B-F3F4-4843-B7AF-98B7BC60DCDE")]
[assembly: AssemblyFileVersion("1.0.5")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.5.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class ExtensionMarkerAttribute : Attribute
	{
		private readonly string <Name>k__BackingField;

		public string Name => <Name>k__BackingField;

		public ExtensionMarkerAttribute(string name)
		{
			<Name>k__BackingField = name;
		}
	}
}
namespace Homestead
{
	internal static class AzuCraftyBoxesCompat
	{
		private const string ApiTypeName = "AzuCraftyBoxes.API";

		private const string PluginTypeName = "AzuCraftyBoxes.AzuCraftyBoxesPlugin";

		private const string MiscFunctionsTypeName = "AzuCraftyBoxes.Util.Functions.MiscFunctions";

		private const string BoxesTypeName = "AzuCraftyBoxes.Util.Functions.Boxes";

		private const float FallbackRange = 20f;

		private const float PatchRetryIntervalSeconds = 2f;

		private static readonly HashSet<string> ProtectedContainerPrefabs = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "piece_chest_wood_blueprint", "piece_chest_barrel_blueprint_store_price", "piece_chest_blueprint_store_purchase", "piece_chest_blackmetal_blueprint_store_payout" };

		private static bool _initialized;

		private static ManualLogSource? _logger;

		private static Harmony? _harmony;

		private static Type? _apiType;

		private static Type? _pluginType;

		private static Type? _miscFunctionsType;

		private static Type? _boxesType;

		private static Type? _queryFrameType;

		private static MethodInfo? _getNearbyContainersDefinition;

		private static MethodInfo? _canItemBePulled;

		private static MethodInfo? _apiRemoveContainer;

		private static MethodInfo? _boxesRemoveContainer;

		private static MethodInfo? _shouldPrevent;

		private static MethodInfo? _checkAndDecrement;

		private static FieldInfo? _rangeField;

		private static bool _pullFilterPatchApplied;

		private static bool _loggedPullFilterPatchFailure;

		private static float _nextPatchRetryAt;

		internal static bool IsLoaded
		{
			get
			{
				EnsureInitialized();
				if (_apiType != null)
				{
					return InvokeStaticBool(_apiType.GetMethod("IsLoaded", BindingFlags.Static | BindingFlags.Public), fallback: true);
				}
				return false;
			}
		}

		internal static void Initialize(ManualLogSource logger, Harmony harmony)
		{
			_logger = logger;
			_harmony = harmony;
			EnsureInitialized(force: true);
			TryPatchPullFilter();
		}

		internal static void Update()
		{
			if (!_pullFilterPatchApplied && Time.realtimeSinceStartup >= _nextPatchRetryAt)
			{
				TryPatchPullFilter();
			}
		}

		internal static int PullMissingMaterials(Component source, IReadOnlyList<ZoneBlueprintRequirement> missingRequirements, Action<ZoneBlueprintRequirement, int> acceptPulledMaterial)
		{
			if ((Object)(object)source == (Object)null || missingRequirements.Count == 0 || acceptPulledMaterial == null)
			{
				return 0;
			}
			EnsureInitialized();
			if (!IsUsable())
			{
				return 0;
			}
			if (InvokeStaticBool(_shouldPrevent, fallback: false))
			{
				return 0;
			}
			IEnumerable nearbyContainers = GetNearbyContainers(source, GetPullRange());
			if (nearbyContainers == null)
			{
				return 0;
			}
			int num = 0;
			foreach (ZoneBlueprintRequirement item in missingRequirements.Where((ZoneBlueprintRequirement requirement) => requirement.Amount > 0))
			{
				int num2 = item.Amount;
				foreach (object item2 in nearbyContainers)
				{
					if (num2 <= 0)
					{
						break;
					}
					string text = InvokeString(item2, "GetPrefabName");
					if (!string.IsNullOrWhiteSpace(text) && !string.Equals(text, "piece_chest_wood_blueprint", StringComparison.OrdinalIgnoreCase) && !ZoneBlueprintStoreChestPrefab.IsStorePrefabName(text) && CanItemBePulled(text, item.PrefabName))
					{
						int amount = InvokeInt(item2, "ItemCount", item.ItemName);
						int num3 = Mathf.Max(0, CheckAndDecrement(amount));
						int num4 = Mathf.Min(num2, num3);
						if (num4 > 0)
						{
							InvokeVoid(item2, "RemoveItem", item.ItemName, num4);
							InvokeVoid(item2, "Save");
							acceptPulledMaterial(item, num4);
							num2 -= num4;
							num += num4;
						}
					}
				}
			}
			return num;
		}

		internal static void RemoveContainer(Container? container, string source)
		{
			if (!Object.op_Implicit((Object)(object)container))
			{
				return;
			}
			EnsureInitialized(_apiType == null || _boxesType == null);
			int num = 0 | (InvokeStaticVoid(_apiRemoveContainer, container) ? 1 : 0) | (InvokeStaticVoid(_boxesRemoveContainer, container) ? 1 : 0) | (RemoveContainerFromAzuSets(container) ? 1 : 0);
			InvalidateNearbyContainerCache();
			if (num != 0)
			{
				ManualLogSource? logger = _logger;
				if (logger != null)
				{
					logger.LogDebug((object)("Removed Homestead container from AzuCraftyBoxes registry/cache (" + source + "): " + NormalizePrefabName(((Object)container).name ?? "")));
				}
			}
		}

		private static void EnsureInitialized(bool force = false)
		{
			if (!_initialized || force)
			{
				_initialized = true;
				_apiType = FindType("AzuCraftyBoxes.API");
				_pluginType = FindType("AzuCraftyBoxes.AzuCraftyBoxesPlugin");
				_miscFunctionsType = FindType("AzuCraftyBoxes.Util.Functions.MiscFunctions");
				_boxesType = FindType("AzuCraftyBoxes.Util.Functions.Boxes");
				_queryFrameType = _boxesType?.GetNestedType("QueryFrame", BindingFlags.Public | BindingFlags.NonPublic);
				_getNearbyContainersDefinition = _apiType?.GetMethods(BindingFlags.Static | BindingFlags.Public).FirstOrDefault((MethodInfo method) => method.Name == "GetNearbyContainers" && method.IsGenericMethodDefinition);
				_canItemBePulled = _apiType?.GetMethod("CanItemBePulled", BindingFlags.Static | BindingFlags.Public, null, new Type[2]
				{
					typeof(string),
					typeof(string)
				}, null);
				_apiRemoveContainer = _apiType?.GetMethod("RemoveContainer", BindingFlags.Static | BindingFlags.Public, null, new Type[1] { typeof(Container) }, null);
				_boxesRemoveContainer = _boxesType?.GetMethod("RemoveContainer", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(Container) }, null);
				_shouldPrevent = _miscFunctionsType?.GetMethod("ShouldPrevent", BindingFlags.Static | BindingFlags.NonPublic);
				_checkAndDecrement = _boxesType?.GetMethod("CheckAndDecrement", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				_rangeField = _pluginType?.GetField("mRange", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			}
		}

		private static void TryPatchPullFilter()
		{
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Expected O, but got Unknown
			if (_pullFilterPatchApplied || _harmony == null)
			{
				return;
			}
			EnsureInitialized(_boxesType == null);
			_nextPatchRetryAt = Time.realtimeSinceStartup + 2f;
			if (_boxesType == null)
			{
				return;
			}
			MethodInfo methodInfo = _boxesType.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault(delegate(MethodInfo method)
			{
				if (method.Name != "CanItemBePulled")
				{
					return false;
				}
				ParameterInfo[] parameters = method.GetParameters();
				return parameters.Length >= 2 && parameters[0].ParameterType == typeof(string) && parameters[1].ParameterType == typeof(string);
			});
			MethodInfo method2 = typeof(AzuCraftyBoxesCompat).GetMethod("CanItemBePulledPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			if (methodInfo == null || method2 == null)
			{
				if (!_loggedPullFilterPatchFailure)
				{
					_loggedPullFilterPatchFailure = true;
					ManualLogSource? logger = _logger;
					if (logger != null)
					{
						logger.LogDebug((object)"AzuCraftyBoxes CanItemBePulled patch target is not available yet.");
					}
				}
				return;
			}
			try
			{
				_harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(method2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				_pullFilterPatchApplied = true;
				ManualLogSource? logger2 = _logger;
				if (logger2 != null)
				{
					logger2.LogInfo((object)"AzuCraftyBoxes pull filter patched for Homestead blueprint containers.");
				}
			}
			catch (Exception ex)
			{
				if (!_loggedPullFilterPatchFailure)
				{
					_loggedPullFilterPatchFailure = true;
					ManualLogSource? logger3 = _logger;
					if (logger3 != null)
					{
						logger3.LogDebug((object)("Could not patch AzuCraftyBoxes pull filter: " + ex.Message));
					}
				}
			}
		}

		private static bool CanItemBePulledPrefix(string container, ref bool __result)
		{
			if (!IsProtectedContainerPrefab(container))
			{
				return true;
			}
			__result = false;
			return false;
		}

		private static bool IsProtectedContainerPrefab(string? prefabName)
		{
			string text = prefabName ?? "";
			if (string.IsNullOrWhiteSpace(text))
			{
				return false;
			}
			return ProtectedContainerPrefabs.Contains(NormalizePrefabName(text));
		}

		private static string NormalizePrefabName(string prefabName)
		{
			int num = prefabName.IndexOfAny(new char[2] { '(', ' ' });
			if (num >= 0)
			{
				return prefabName.Substring(0, num);
			}
			return prefabName;
		}

		private static bool InvokeStaticVoid(MethodInfo? method, Container container)
		{
			try
			{
				method?.Invoke(null, new object[1] { container });
				return method != null;
			}
			catch
			{
				return false;
			}
		}

		private static bool RemoveContainerFromAzuSets(Container container)
		{
			return false | RemoveContainerFromSet("Containers", container) | RemoveContainerFromSet("ContainersToAdd", container) | RemoveContainerFromSet("ContainersToRemove", container);
		}

		private static bool RemoveContainerFromSet(string fieldName, Container container)
		{
			try
			{
				object obj = _boxesType?.GetField(fieldName, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(null);
				object obj2 = (obj?.GetType().GetMethod("Remove", new Type[1] { typeof(Container) }))?.Invoke(obj, new object[1] { container });
				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;
			}
		}

		private static void InvalidateNearbyContainerCache()
		{
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				_queryFrameType?.GetField("FrameId", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)?.SetValue(null, -1);
				_queryFrameType?.GetField("Nearby", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)?.SetValue(null, null);
				ClearListField(_boxesType, "_cachedAll");
				ClearListField(_boxesType, "_scratchNearby");
				_boxesType?.GetField("_lastQueryTime", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)?.SetValue(null, float.NegativeInfinity);
				_boxesType?.GetField("_lastQueryRange", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)?.SetValue(null, -1f);
				_boxesType?.GetField("_lastQueryPos", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)?.SetValue(null, Vector3.positiveInfinity);
			}
			catch
			{
			}
		}

		private static void ClearListField(Type? type, string fieldName)
		{
			try
			{
				if (type?.GetField(fieldName, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(null) is IList list)
				{
					list.Clear();
				}
			}
			catch
			{
			}
		}

		private static bool IsUsable()
		{
			if (_apiType != null && _getNearbyContainersDefinition != null)
			{
				return _canItemBePulled != null;
			}
			return false;
		}

		private static IEnumerable? GetNearbyContainers(Component source, float range)
		{
			try
			{
				return _getNearbyContainersDefinition.MakeGenericMethod(((object)source).GetType()).Invoke(null, new object[2] { source, range }) as IEnumerable;
			}
			catch
			{
				return null;
			}
		}

		private static float GetPullRange()
		{
			try
			{
				object obj = _rangeField?.GetValue(null);
				object obj2 = obj?.GetType().GetProperty("Value")?.GetValue(obj, null);
				if (obj2 != null)
				{
					return Mathf.Max(1f, Convert.ToSingle(obj2, CultureInfo.InvariantCulture));
				}
			}
			catch
			{
			}
			return 20f;
		}

		private static bool CanItemBePulled(string containerPrefab, string itemPrefab)
		{
			try
			{
				object obj = _canItemBePulled?.Invoke(null, new object[2] { containerPrefab, itemPrefab });
				bool flag = default(bool);
				int num;
				if (obj is bool)
				{
					flag = (bool)obj;
					num = 1;
				}
				else
				{
					num = 0;
				}
				return (byte)((uint)num & (flag ? 1u : 0u)) != 0;
			}
			catch
			{
				return false;
			}
		}

		private static int CheckAndDecrement(int amount)
		{
			try
			{
				return (_checkAndDecrement?.Invoke(null, new object[1] { amount }) is int num) ? num : amount;
			}
			catch
			{
				return amount;
			}
		}

		private static Type? FindType(string fullName)
		{
			string fullName2 = fullName;
			return (from assembly in AppDomain.CurrentDomain.GetAssemblies()
				select assembly.GetType(fullName2, throwOnError: false)).FirstOrDefault((Type type) => type != null);
		}

		private static string InvokeString(object target, string methodName)
		{
			try
			{
				return (target.GetType().GetMethod(methodName, BindingFlags.Instance | BindingFlags.Public)?.Invoke(target, Array.Empty<object>()) as string) ?? "";
			}
			catch
			{
				return "";
			}
		}

		private static int InvokeInt(object target, string methodName, params object[] args)
		{
			try
			{
				return (target.GetType().GetMethod(methodName, BindingFlags.Instance | BindingFlags.Public)?.Invoke(target, args) is int num) ? num : 0;
			}
			catch
			{
				return 0;
			}
		}

		private static void InvokeVoid(object target, string methodName, params object[] args)
		{
			try
			{
				target.GetType().GetMethod(methodName, BindingFlags.Instance | BindingFlags.Public)?.Invoke(target, args);
			}
			catch
			{
			}
		}

		private static bool InvokeStaticBool(MethodInfo? method, bool fallback)
		{
			try
			{
				return (method?.Invoke(null, Array.Empty<object>()) is bool flag) ? flag : fallback;
			}
			catch
			{
				return fallback;
			}
		}

		private static Exception Unwrap(Exception ex)
		{
			if (!(ex is TargetInvocationException) || ex.InnerException == null)
			{
				return ex;
			}
			return ex.InnerException;
		}
	}
	internal static class AzuExtendedPlayerInventoryCompat
	{
		private const string PluginGuid = "Azumatt.AzuExtendedPlayerInventory";

		private const string CustomEquipVisualsTypeName = "AzuEPI.Game.PlayerPreview.CustomEquipVisuals";

		private static readonly BindingFlags StaticFieldFlags = BindingFlags.Static | BindingFlags.NonPublic;

		private static readonly BindingFlags InstanceFieldFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;

		private static bool _initialized;

		private static bool _loaded;

		private static FieldInfo? _statesField;

		public static bool IsLoaded
		{
			get
			{
				EnsureInitialized();
				return _loaded;
			}
		}

		public static bool TryGetCustomEquippedItem(Player player, Func<ItemData?, bool> predicate, out ItemData? item)
		{
			item = null;
			if (!IsLoaded || !Object.op_Implicit((Object)(object)player))
			{
				return false;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory == null)
			{
				return false;
			}
			foreach (ItemData allItem in inventory.GetAllItems())
			{
				if (allItem != null && allItem.m_equipped && allItem != ((Humanoid)player).m_helmetItem && allItem != ((Humanoid)player).m_chestItem && allItem != ((Humanoid)player).m_legItem && allItem != ((Humanoid)player).m_shoulderItem && allItem != ((Humanoid)player).m_utilityItem && allItem != ((Humanoid)player).m_trinketItem && predicate(allItem))
				{
					item = allItem;
					return true;
				}
			}
			return false;
		}

		public static bool TryGetCustomEquipVisualRoots(VisEquipment visEquipment, ItemData item, List<GameObject> roots)
		{
			roots.Clear();
			if (!IsLoaded || !Object.op_Implicit((Object)(object)visEquipment) || item == null || _statesField == null)
			{
				return false;
			}
			try
			{
				if (!(_statesField.GetValue(null) is IDictionary dictionary) || !dictionary.Contains(visEquipment))
				{
					return false;
				}
				object obj = dictionary[visEquipment];
				if (obj == null)
				{
					return false;
				}
				if (!(obj.GetType().GetField("Equipped", InstanceFieldFlags)?.GetValue(obj) is IDictionary dictionary2))
				{
					return false;
				}
				foreach (DictionaryEntry item2 in dictionary2)
				{
					object value = item2.Value;
					if (value == null)
					{
						continue;
					}
					Type type = value.GetType();
					if (type.GetField("Item", InstanceFieldFlags)?.GetValue(value) != item || !(type.GetField("Instances", InstanceFieldFlags)?.GetValue(value) is IEnumerable enumerable))
					{
						continue;
					}
					foreach (object item3 in enumerable)
					{
						GameObject val = (GameObject)((item3 is GameObject) ? item3 : null);
						if (val != null && Object.op_Implicit((Object)(object)val))
						{
							roots.Add(val);
						}
					}
				}
			}
			catch
			{
				roots.Clear();
			}
			return roots.Count > 0;
		}

		public static void ResetForWorldSession()
		{
			if (!_loaded)
			{
				_initialized = false;
				_statesField = null;
			}
		}

		private static void EnsureInitialized()
		{
			if (!_initialized)
			{
				_initialized = true;
				if (Chainloader.PluginInfos.TryGetValue("Azumatt.AzuExtendedPlayerInventory", out var value))
				{
					_statesField = ((((object)value.Instance)?.GetType().Assembly)?.GetType("AzuEPI.Game.PlayerPreview.CustomEquipVisuals", throwOnError: false))?.GetField("_states", StaticFieldFlags);
					_loaded = true;
				}
			}
		}
	}
	internal static class BlueprintTerrainApplier
	{
		public static List<ZoneBlueprintTerrainContact> CaptureContacts(Vector3 anchor, Quaternion inverseAnchorRotation, IEnumerable<TerrainContactSource> sources)
		{
			//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)
			List<TerrainWorldContact> contacts = BlueprintTerrainContactSampler.CaptureWorldContacts(sources, BlueprintConfig.TerrainSupportContactTolerance);
			return BlueprintTerrainContactSampler.ToBlueprintContacts(anchor, inverseAnchorRotation, contacts);
		}

		public static bool ApplySupportContacts(IEnumerable<Vector3> supportContacts)
		{
			return HomesteadTerrainSupport.ApplyWorldSupportContacts(supportContacts);
		}

		public static IEnumerator ApplySupportContactsAsync(IEnumerable<Vector3> supportContacts, Action<bool> onComplete)
		{
			return HomesteadTerrainSupport.ApplyWorldSupportContactsAsync(supportContacts, onComplete);
		}
	}
	internal static class BlueprintTerrainContactSampler
	{
		public static List<TerrainWorldContact> CaptureWorldContacts(IEnumerable<TerrainContactSource> sources, float tolerance)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: 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_005d: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<long, TerrainWorldContact> dictionary = new Dictionary<long, TerrainWorldContact>();
			foreach (TerrainContactSource source in sources)
			{
				if (Object.op_Implicit((Object)(object)source.Prefab) && !((Object)(object)source.Prefab.GetComponent<WearNTear>() == (Object)null) && HomesteadTerrainSupport.TryGetWearNTearBounds(source.Prefab, source.Position, source.Rotation, source.Scale, out var bounds))
				{
					AddLowestBoundsFootprintContacts(bounds, dictionary);
				}
			}
			List<TerrainWorldContact> list = new List<TerrainWorldContact>();
			foreach (TerrainWorldContact item in from contact in dictionary.Values
				orderby contact.WorldZ, contact.WorldX
				select contact)
			{
				if (HomesteadTerrainSupport.TryGetTerrainHeight(item.WorldX, item.WorldZ, out var height) && !(Mathf.Abs(height - item.WorldY) > tolerance))
				{
					list.Add(item);
				}
			}
			return list;
		}

		public static List<ZoneBlueprintTerrainContact> ToBlueprintContacts(Vector3 anchor, Quaternion inverseAnchorRotation, IEnumerable<TerrainWorldContact> contacts)
		{
			//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_000e: 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)
			return (from contact in contacts.Select(delegate(TerrainWorldContact contact)
				{
					//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_0013: 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_0024: 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_0046: Unknown result type (might be due to invalid IL or missing references)
					Vector3 val = inverseAnchorRotation * (contact.ToVector3() - anchor);
					return new ZoneBlueprintTerrainContact
					{
						LocalX = Round(val.x),
						LocalY = Round(val.y),
						LocalZ = Round(val.z)
					};
				})
				orderby contact.LocalZ, contact.LocalX
				select contact).ToList();
		}

		private static void AddLowestBoundsFootprintContacts(Bounds bounds, Dictionary<long, TerrainWorldContact> lowestByCell)
		{
			//IL_0002: 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_0020: 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_0044: Unknown result type (might be due to invalid IL or missing references)
			float y = ((Bounds)(ref bounds)).min.y;
			int num = Mathf.FloorToInt(((Bounds)(ref bounds)).min.x);
			int num2 = Mathf.CeilToInt(((Bounds)(ref bounds)).max.x);
			int num3 = Mathf.FloorToInt(((Bounds)(ref bounds)).min.z);
			int num4 = Mathf.CeilToInt(((Bounds)(ref bounds)).max.z);
			for (int i = num; i <= num2; i++)
			{
				for (int j = num3; j <= num4; j++)
				{
					long key = PackCell(i, j);
					TerrainWorldContact value = new TerrainWorldContact(i, j, y);
					if (!lowestByCell.TryGetValue(key, out var value2) || value.WorldY < value2.WorldY)
					{
						lowestByCell[key] = value;
					}
				}
			}
		}

		private static long PackCell(int x, int z)
		{
			return ((long)x << 32) ^ (uint)z;
		}

		private static float Round(float value)
		{
			return Mathf.Round(value * 1000f) / 1000f;
		}
	}
	internal readonly struct TerrainContactSource
	{
		public GameObject Prefab { get; }

		public Vector3 Position { get; }

		public Quaternion Rotation { get; }

		public Vector3 Scale { get; }

		public TerrainContactSource(GameObject prefab, Vector3 position, Quaternion rotation, Vector3 scale)
		{
			//IL_0008: 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_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)
			//IL_0016: 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)
			Prefab = prefab;
			Position = position;
			Rotation = rotation;
			Scale = scale;
		}
	}
	internal readonly struct TerrainWorldContact
	{
		public float WorldX { get; }

		public float WorldZ { get; }

		public float WorldY { get; }

		public TerrainWorldContact(int cellX, int cellZ, float worldY)
		{
			WorldX = cellX;
			WorldZ = cellZ;
			WorldY = worldY;
		}

		public Vector3 ToVector3()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(WorldX, WorldY, WorldZ);
		}
	}
	[BepInPlugin("sighsorry.Homestead", "Homestead", "1.0.5")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class HomesteadPlugin : BaseUnityPlugin
	{
		public enum Toggle
		{
			On = 1,
			Off = 0
		}

		internal const string ModName = "Homestead";

		internal const string ModVersion = "1.0.5";

		internal const string Author = "sighsorry";

		internal const string ModGUID = "sighsorry.Homestead";

		internal const string DataStorageFolder = "Homestead";

		internal const string BlueprintStorageFolder = "Blueprints";

		internal const string ServerBlueprintStorageFolder = "ServerBlueprints";

		internal const string PlanGhostStorageFolder = "PlanGhosts";

		internal const string BlueprintStoreStorageFolder = "Store";

		private const string ConfigFileName = "sighsorry.Homestead.cfg";

		private const long ReloadDelay = 10000000L;

		private static readonly string ConfigFileFullPath = Path.Combine(Paths.ConfigPath, "sighsorry.Homestead.cfg");

		internal static readonly string DataStorageFullPath = Path.Combine(Paths.ConfigPath, "Homestead");

		internal static readonly string BlueprintStorageFullPath = Path.Combine(DataStorageFullPath, "Blueprints");

		internal static readonly string ServerBlueprintStorageFullPath = Path.Combine(DataStorageFullPath, "ServerBlueprints");

		internal static readonly string PlanGhostStorageFullPath = Path.Combine(ServerBlueprintStorageFullPath, "PlanGhosts");

		internal static readonly string BlueprintStoreStorageFullPath = Path.Combine(ServerBlueprintStorageFullPath, "Store");

		internal static readonly ManualLogSource HomesteadLogger = Logger.CreateLogSource("Homestead");

		internal static readonly ConfigSync ConfigSync = new ConfigSync("sighsorry.Homestead")
		{
			DisplayName = "Homestead",
			CurrentVersion = "1.0.5",
			MinimumRequiredVersion = "1.0.5"
		};

		internal static string ConnectionError = "";

		private readonly Harmony _harmony = new Harmony("sighsorry.Homestead");

		private readonly object _reloadLock = new object();

		private FileSystemWatcher? _configWatcher;

		private DateTime _lastConfigReloadTime;

		internal static HomesteadPlugin Instance { get; private set; } = null;


		private void BindConfiguration()
		{
			BindSharedConfiguration();
			BindConstructionConfiguration();
		}

		private void BindSharedConfiguration()
		{
			GeneralConfig.Bind(this);
			ClientConfig.Bind(this);
		}

		private void BindConstructionConfiguration()
		{
			BlueprintConfig.Bind(this);
			BuildCameraConfig.Bind(this);
			PlacementControlConfig.Bind(this);
			DvergrCircletConfig.Bind(this);
		}

		public void Awake()
		{
			Instance = this;
			bool saveOnConfigSet = ((BaseUnityPlugin)this).Config.SaveOnConfigSet;
			((BaseUnityPlugin)this).Config.SaveOnConfigSet = false;
			BindConfiguration();
			HomesteadLocalization.Load(HomesteadLogger);
			EnsureDataDirectories();
			HomesteadFeatureBootstrap.Initialize(HomesteadLogger, _harmony);
			SetupWatchers();
			SaveWithRespectToConfigSet();
			if (saveOnConfigSet)
			{
				((BaseUnityPlugin)this).Config.SaveOnConfigSet = true;
			}
		}

		private void OnDestroy()
		{
			SaveWithRespectToConfigSet();
			HomesteadFeatureBootstrap.Shutdown();
			_configWatcher?.Dispose();
		}

		private void Update()
		{
			HomesteadFeatureBootstrap.Update();
		}

		private void SetupWatchers()
		{
			EnsureDataDirectories();
			_configWatcher = new FileSystemWatcher(Paths.ConfigPath, "sighsorry.Homestead.cfg");
			_configWatcher.Changed += ReadConfigValues;
			_configWatcher.Created += ReadConfigValues;
			_configWatcher.Renamed += ReadConfigValues;
			_configWatcher.IncludeSubdirectories = false;
			_configWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
			_configWatcher.EnableRaisingEvents = true;
		}

		private static void EnsureDataDirectories()
		{
			Directory.CreateDirectory(DataStorageFullPath);
			Directory.CreateDirectory(BlueprintStorageFullPath);
			Directory.CreateDirectory(PlanGhostStorageFullPath);
			Directory.CreateDirectory(BlueprintStoreStorageFullPath);
		}

		private void ReadConfigValues(object sender, FileSystemEventArgs e)
		{
			if (!CanReload(ref _lastConfigReloadTime))
			{
				return;
			}
			lock (_reloadLock)
			{
				if (!File.Exists(ConfigFileFullPath))
				{
					HomesteadLogger.LogWarning((object)"Config file does not exist. Skipping reload.");
					return;
				}
				try
				{
					HomesteadLogger.LogDebug((object)"Reloading configuration...");
					ReloadConfigFromDisk();
					HomesteadLogger.LogInfo((object)"Configuration reload complete.");
				}
				catch (Exception arg)
				{
					HomesteadLogger.LogError((object)$"Error reloading configuration: {arg}");
				}
			}
		}

		private static bool CanReload(ref DateTime lastReloadTime)
		{
			DateTime now = DateTime.Now;
			if (now.Ticks - lastReloadTime.Ticks < 10000000)
			{
				return false;
			}
			lastReloadTime = now;
			return true;
		}

		private void SaveWithRespectToConfigSet(bool reload = false)
		{
			bool saveOnConfigSet = ((BaseUnityPlugin)this).Config.SaveOnConfigSet;
			((BaseUnityPlugin)this).Config.SaveOnConfigSet = false;
			if (reload)
			{
				((BaseUnityPlugin)this).Config.Reload();
			}
			((BaseUnityPlugin)this).Config.Save();
			((BaseUnityPlugin)this).Config.SaveOnConfigSet = saveOnConfigSet;
		}

		private void ReloadConfigFromDisk()
		{
			bool saveOnConfigSet = ((BaseUnityPlugin)this).Config.SaveOnConfigSet;
			((BaseUnityPlugin)this).Config.SaveOnConfigSet = false;
			((BaseUnityPlugin)this).Config.Reload();
			((BaseUnityPlugin)this).Config.SaveOnConfigSet = saveOnConfigSet;
		}

		internal ConfigEntry<T> config<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]" : " [Client Only]"), description.AcceptableValues, description.Tags);
			ConfigEntry<T> val2 = ((BaseUnityPlugin)this).Config.Bind<T>(group, name, value, val);
			ConfigSync.AddConfigEntry<T>(val2).SynchronizedConfig = synchronizedSetting;
			return val2;
		}

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

		public string Message { get; set; } = "";


		public static HomesteadCommandResult Ok(string message)
		{
			return new HomesteadCommandResult
			{
				Success = true,
				Message = message
			};
		}

		public static HomesteadCommandResult Fail(string message)
		{
			return new HomesteadCommandResult
			{
				Success = false,
				Message = message
			};
		}
	}
	internal static class GeneralConfig
	{
		private static ConfigEntry<HomesteadPlugin.Toggle> _serverConfigLocked;

		public static void Bind(HomesteadPlugin plugin)
		{
			_serverConfigLocked = plugin.config("01 - General", "Lock Configuration", HomesteadPlugin.Toggle.On, "If on, the server controls synced settings.");
			HomesteadPlugin.ConfigSync.AddLockingConfigEntry<HomesteadPlugin.Toggle>(_serverConfigLocked);
		}
	}
	internal static class ClientConfig
	{
		private static ConfigEntry<float> _counterVisibleSeconds;

		private static ConfigEntry<float> _statusHudX;

		private static ConfigEntry<float> _statusHudY;

		private static ConfigEntry<int> _statusHudFontSize;

		public static float CounterVisibleSeconds => Mathf.Max(0.1f, _counterVisibleSeconds.Value);

		public static Vector2 StatusHudPosition => new Vector2(Mathf.Clamp(_statusHudX.Value, 0f, 3000f), 0f - Mathf.Clamp(_statusHudY.Value, 0f, 3000f));

		public static int StatusHudFontSize => Mathf.Clamp(_statusHudFontSize.Value, 10, 64);

		public static void Bind(HomesteadPlugin plugin)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Expected O, but got Unknown
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Expected O, but got Unknown
			_counterVisibleSeconds = plugin.config("02 - Client", "Build Counter Visible Seconds", 2.5f, new ConfigDescription("How long the top build counter stays visible after you place a build piece.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 10f), Array.Empty<object>()), synchronizedSetting: false);
			_statusHudX = plugin.config("02 - Client", "Status HUD X Offset", 28f, new ConfigDescription("Client-only X offset in pixels from the top-left corner for the unified status HUD.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3000f), Array.Empty<object>()), synchronizedSetting: false);
			_statusHudY = plugin.config("02 - Client", "Status HUD Y Offset", 116f, new ConfigDescription("Client-only Y offset in pixels from the top-left corner for the unified status HUD.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3000f), Array.Empty<object>()), synchronizedSetting: false);
			_statusHudFontSize = plugin.config("02 - Client", "Status HUD Font Size", 18, new ConfigDescription("Client-only font size for the unified status HUD. HUD width and height are calculated from this value.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(10, 64), Array.Empty<object>()), synchronizedSetting: false);
		}
	}
	internal readonly struct BlueprintNetworkSettings
	{
		public int MaxUploadBytes { get; }

		public int MaxEntries { get; }

		public int MaxPreviewEntries { get; }

		public int MaxIconBytes { get; }

		public BlueprintNetworkSettings(int maxUploadBytes, int maxEntries, int maxPreviewEntries, int maxIconBytes)
		{
			MaxUploadBytes = maxUploadBytes;
			MaxEntries = maxEntries;
			MaxPreviewEntries = maxPreviewEntries;
			MaxIconBytes = maxIconBytes;
		}
	}
	internal readonly struct BlueprintStoreSettings
	{
		public int ListingDays { get; }

		public int AutoDelistMaxPurchases { get; }

		public int MaxListingsPerSteamId { get; }

		public BlueprintStoreIdentityMode IdentityMode { get; }

		public BlueprintStoreSettings(int listingDays, int autoDelistMaxPurchases, int maxListingsPerSteamId, BlueprintStoreIdentityMode identityMode)
		{
			ListingDays = listingDays;
			AutoDelistMaxPurchases = autoDelistMaxPurchases;
			MaxListingsPerSteamId = maxListingsPerSteamId;
			IdentityMode = identityMode;
		}
	}
	internal static class BlueprintConfig
	{
		private static ConfigEntry<BlueprintTerrainSupportMode> _terrainSupport = null;

		private static ConfigEntry<int> _chestRows = null;

		private static ConfigEntry<KeyboardShortcut> _chestConfirmHotkey = null;

		private static ConfigEntry<BlueprintAzuCraftyBoxesPullMode> _azuCraftyBoxesPullMode = null;

		private static ConfigEntry<float> _terrainSupportContactTolerance = null;

		private static ConfigEntry<float> _terrainSupportFeatherWidth = null;

		private static ConfigEntry<int> _maxUploadKb = null;

		private static ConfigEntry<int> _maxEntries = null;

		private static ConfigEntry<int> _maxPreviewEntries = null;

		private static ConfigEntry<int> _maxIconKb = null;

		private static ConfigEntry<int> _storeListingDays = null;

		private static ConfigEntry<int> _storeAutoDelistMaxPurchases = null;

		private static ConfigEntry<int> _storeMaxListingsPerSteamId = null;

		private static ConfigEntry<BlueprintStoreIdentityMode> _storeIdentityMode = null;

		private static ConfigEntry<int> _chestTimeoutMinutes = null;

		private static ConfigEntry<int> _chestMapIconSize = null;

		private static ConfigEntry<int> _maxActiveChestsPerPlayer = null;

		private static ConfigEntry<float> _storeLargePanelScale = null;

		private static ConfigEntry<float> _storeLargePanelX = null;

		private static ConfigEntry<float> _storeLargePanelY = null;

		private static ConfigEntry<float> _storeFormPanelScale = null;

		private static ConfigEntry<float> _storeFormPanelX = null;

		private static ConfigEntry<float> _storeFormPanelY = null;

		private static ConfigEntry<HomesteadPlugin.Toggle> _storeAnonymousNotifications = null;

		private static ConfigEntry<BlueprintStoreNotificationMode> _storeNotificationMode = null;

		private static ConfigEntry<HomesteadPlugin.Toggle> _storeDebugLogging = null;

		private static ConfigEntry<float> _storeNotificationButtonX = null;

		private static ConfigEntry<float> _storeNotificationButtonY = null;

		private static ConfigEntry<KeyboardShortcut> _storeListModifierKey = null;

		private static ConfigEntry<KeyboardShortcut> _storeBackHotkey = null;

		private static ConfigEntry<Color> _storeListingPreviewColor = null;

		private static ConfigEntry<Color> _storePurchasePreviewColor = null;

		private static ConfigEntry<float> _areaSaveMaxSide = null;

		private static ConfigEntry<float> _areaSaveDefaultWidth = null;

		private static ConfigEntry<float> _areaSaveDefaultDepth = null;

		private static ConfigEntry<BlueprintAreaSaveCreatorMode> _areaSaveCreatorMode = null;

		private static ConfigEntry<Color> _areaSaveBoundaryColor = null;

		private static ConfigEntry<float> _areaDismantleMaxSide = null;

		private static ConfigEntry<float> _areaDismantleDefaultWidth = null;

		private static ConfigEntry<float> _areaDismantleDefaultDepth = null;

		private static ConfigEntry<Color> _areaDismantleBoundaryColor = null;

		private static ConfigEntry<string> _areaDismantlePrefabBlacklist = null;

		private static ConfigEntry<KeyboardShortcut> _areaToolDepthModifierKey = null;

		private static ConfigEntry<KeyboardShortcut> _areaToolWidthModifierKey = null;

		private static ConfigEntry<Color> _previewGhostColor = null;

		private static ConfigEntry<float> _previewGhostBrightness = null;

		private static readonly HashSet<string> BuiltInAreaDismantleProtectedPrefabs = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "piece_chest_wood_blueprint", "piece_chest_barrel_blueprint_store_price", "piece_chest_blueprint_store_purchase", "piece_chest_blackmetal_blueprint_store_payout" };

		public static bool TerrainSupportEnabled => _terrainSupport.Value == BlueprintTerrainSupportMode.On;

		public static int ChestRows => Mathf.Clamp(_chestRows.Value, 10, 40);

		public static KeyboardShortcut ChestConfirmHotkey => _chestConfirmHotkey.Value;

		public static bool AzuCraftyBoxesPullOnConfirm => _azuCraftyBoxesPullMode.Value != BlueprintAzuCraftyBoxesPullMode.Off;

		public static bool AzuCraftyBoxesPullOnOpen => _azuCraftyBoxesPullMode.Value == BlueprintAzuCraftyBoxesPullMode.OpenAndConfirm;

		public static float TerrainSupportContactTolerance => Mathf.Clamp(_terrainSupportContactTolerance.Value, 0.01f, 2f);

		public static float TerrainSupportFeatherWidth => Mathf.Clamp(_terrainSupportFeatherWidth.Value, 0f, 64f);

		public static int MaxUploadKb => Mathf.Clamp(_maxUploadKb.Value, 64, 16384);

		public static int MaxUploadBytes => MaxUploadKb * 1024;

		public static int MaxEntries => Mathf.Clamp(_maxEntries.Value, 1, 20000);

		public static int MaxPreviewEntries => Mathf.Clamp(_maxPreviewEntries.Value, 1, MaxEntries);

		public static int MaxIconKb => Mathf.Clamp(_maxIconKb.Value, 0, 2048);

		public static int MaxIconBytes => MaxIconKb * 1024;

		public static BlueprintNetworkSettings NetworkSettings => new BlueprintNetworkSettings(MaxUploadBytes, MaxEntries, MaxPreviewEntries, MaxIconBytes);

		public static int StoreListingDays => Mathf.Clamp(_storeListingDays.Value, 0, 365);

		public static int StoreAutoDelistMaxPurchases => Mathf.Clamp(_storeAutoDelistMaxPurchases.Value, 0, 100000);

		public static int StoreMaxListingsPerSteamId => Mathf.Clamp(_storeMaxListingsPerSteamId.Value, 1, 200);

		public static BlueprintStoreIdentityMode StoreIdentityMode => _storeIdentityMode.Value;

		public static BlueprintStoreSettings StoreSettings => new BlueprintStoreSettings(StoreListingDays, StoreAutoDelistMaxPurchases, StoreMaxListingsPerSteamId, StoreIdentityMode);

		public static int ChestTimeoutMinutes => Mathf.Clamp(_chestTimeoutMinutes.Value, 0, 60);

		public static int ChestMapIconSize => Mathf.Clamp(_chestMapIconSize.Value, 0, 10);

		public static int MaxActiveChestsPerPlayer => Mathf.Clamp(_maxActiveChestsPerPlayer.Value, 0, 50);

		public static float StoreLargePanelScale => Mathf.Clamp(_storeLargePanelScale.Value, 0.75f, 2f);

		public static Vector2 StoreLargePanelOffset => new Vector2(Mathf.Clamp(_storeLargePanelX.Value, -2000f, 2000f), Mathf.Clamp(_storeLargePanelY.Value, -2000f, 2000f));

		public static float StoreFormPanelScale => Mathf.Clamp(_storeFormPanelScale.Value, 0.75f, 2f);

		public static Vector2 StoreFormPanelOffset => new Vector2(Mathf.Clamp(_storeFormPanelX.Value, -2000f, 2000f), Mathf.Clamp(_storeFormPanelY.Value, -2000f, 2000f));

		public static float StoreUiScale => StoreLargePanelScale;

		public static int StoreNotificationPollSeconds
		{
			get
			{
				if (!StoreNotificationsEnabled)
				{
					return 0;
				}
				return 900;
			}
		}

		public static BlueprintStoreNotificationMode StoreNotificationMode => _storeNotificationMode.Value;

		public static bool StoreNotificationsEnabled => StoreNotificationMode != BlueprintStoreNotificationMode.Off;

		public static bool StoreNotificationAutoOpen => StoreNotificationMode == BlueprintStoreNotificationMode.AutoOpenPanel;

		public static bool StoreAnonymousNotifications => _storeAnonymousNotifications.Value.IsOn();

		public static bool StoreNotificationButtonEnabled => StoreNotificationsEnabled;

		public static bool StoreDebugLogging => _storeDebugLogging.Value.IsOn();

		public static Vector2 StoreNotificationButtonOffset => new Vector2(Mathf.Clamp(_storeNotificationButtonX.Value, -3000f, 3000f), Mathf.Clamp(_storeNotificationButtonY.Value, -3000f, 3000f));

		public static KeyboardShortcut StoreListModifierKey => _storeListModifierKey.Value;

		public static string StoreListModifierLabel => ConfigValueHelpers.FormatShortcut(StoreListModifierKey);

		public static KeyboardShortcut StoreBackHotkey => _storeBackHotkey.Value;

		public static string StoreBackHotkeyLabel => ConfigValueHelpers.FormatShortcut(StoreBackHotkey);

		public static Color StoreListingPreviewColor => GetStorePendingPreviewColor(_storeListingPreviewColor.Value, new Color(1f, 0.9f, 0.2f, 0.15f));

		public static Color StorePurchasePreviewColor => GetStorePendingPreviewColor(_storePurchasePreviewColor.Value, new Color(1f, 0.54f, 0.12f, 0.15f));

		public static float AreaSaveMaxSide => Mathf.Clamp(_areaSaveMaxSide.Value, 2f, 256f);

		public static float AreaSaveDefaultWidth => Mathf.Clamp(_areaSaveDefaultWidth.Value, 2f, AreaSaveMaxSide);

		public static float AreaSaveDefaultDepth => Mathf.Clamp(_areaSaveDefaultDepth.Value, 2f, AreaSaveMaxSide);

		public static BlueprintAreaSaveCreatorMode AreaSaveCreatorMode => _areaSaveCreatorMode.Value;

		public static string AreaSaveEligibleTargetLabel => AreaSaveCreatorMode switch
		{
			BlueprintAreaSaveCreatorMode.AllCreators => "WearNTear", 
			BlueprintAreaSaveCreatorMode.OwnedAndCreatorless => "owned or creatorless WearNTear", 
			_ => "owned WearNTear", 
		};

		public static Color AreaSaveBoundaryColor => _areaSaveBoundaryColor.Value;

		public static float AreaDismantleMaxSide => Mathf.Clamp(_areaDismantleMaxSide.Value, 1f, 128f);

		public static float AreaDismantleDefaultWidth => Mathf.Clamp(_areaDismantleDefaultWidth.Value, 1f, AreaDismantleMaxSide);

		public static float AreaDismantleDefaultDepth => Mathf.Clamp(_areaDismantleDefaultDepth.Value, 1f, AreaDismantleMaxSide);

		public static Color AreaDismantleBoundaryColor => _areaDismantleBoundaryColor.Value;

		public static HashSet<string> AreaDismantlePrefabBlacklist => ConfigValueHelpers.SplitPrefabList(_areaDismantlePrefabBlacklist.Value);

		public static KeyboardShortcut AreaToolDepthModifierKey => _areaToolDepthModifierKey.Value;

		public static string AreaToolDepthModifierLabel => ConfigValueHelpers.FormatShortcut(AreaToolDepthModifierKey);

		public static string AreaToolDepthInputLabel
		{
			get
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				KeyboardShortcut areaToolDepthModifierKey = AreaToolDepthModifierKey;
				if ((int)((KeyboardShortcut)(ref areaToolDepthModifierKey)).MainKey != 0)
				{
					return AreaToolDepthModifierLabel + "+Wheel";
				}
				return "";
			}
		}

		public static KeyboardShortcut AreaToolWidthModifierKey => _areaToolWidthModifierKey.Value;

		public static string AreaToolWidthModifierLabel => ConfigValueHelpers.FormatShortcut(AreaToolWidthModifierKey);

		public static string AreaToolWidthInputLabel
		{
			get
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				KeyboardShortcut areaToolWidthModifierKey = AreaToolWidthModifierKey;
				if ((int)((KeyboardShortcut)(ref areaToolWidthModifierKey)).MainKey != 0)
				{
					return AreaToolWidthModifierLabel + "+Wheel";
				}
				return "";
			}
		}

		public static Color PreviewGhostColor
		{
			get
			{
				//IL_0005: 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_0027: 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_004f: 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_0073: Unknown result type (might be due to invalid IL or missing references)
				Color value = _previewGhostColor.Value;
				float num = Mathf.Clamp(_previewGhostBrightness.Value, 0.1f, 2f);
				value.r = Mathf.Clamp01(value.r * num);
				value.g = Mathf.Clamp01(value.g * num);
				value.b = Mathf.Clamp01(value.b * num);
				value.a = Mathf.Clamp01(value.a);
				return value;
			}
		}

		public static void SetStoreLargePanelOffset(Vector2 offset)
		{
			//IL_0005: 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)
			_storeLargePanelX.Value = Mathf.Clamp(offset.x, -2000f, 2000f);
			_storeLargePanelY.Value = Mathf.Clamp(offset.y, -2000f, 2000f);
		}

		public static void SetStoreFormPanelOffset(Vector2 offset)
		{
			//IL_0005: 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)
			_storeFormPanelX.Value = Mathf.Clamp(offset.x, -2000f, 2000f);
			_storeFormPanelY.Value = Mathf.Clamp(offset.y, -2000f, 2000f);
		}

		public static void SetStoreNotificationButtonOffset(Vector2 offset)
		{
			//IL_0005: 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)
			_storeNotificationButtonX.Value = Mathf.Clamp(offset.x, -3000f, 3000f);
			_storeNotificationButtonY.Value = Mathf.Clamp(offset.y, -3000f, 3000f);
		}

		public static bool IsStoreListModifierHeld()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return ConfigValueHelpers.IsShortcutHeld(StoreListModifierKey, allowUnbound: true);
		}

		public static bool IsStoreBackHotkeyDown()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return ConfigValueHelpers.IsShortcutDown(StoreBackHotkey);
		}

		public static bool AreaSaveAllowsCreator(long playerId, long creator)
		{
			if (creator == playerId)
			{
				return true;
			}
			return AreaSaveCreatorMode switch
			{
				BlueprintAreaSaveCreatorMode.AllCreators => true, 
				BlueprintAreaSaveCreatorMode.OwnedAndCreatorless => creator == 0, 
				_ => false, 
			};
		}

		public static bool ShouldApplyTerrainSupport(Player player)
		{
			return _terrainSupport.Value switch
			{
				BlueprintTerrainSupportMode.On => true, 
				BlueprintTerrainSupportMode.AdminDebug => IsAdminDebugPlayer(player), 
				_ => false, 
			};
		}

		public static void Bind(HomesteadPlugin plugin)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			//IL_0067: 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_00cc: Expected O, but got Unknown
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Expected O, but got Unknown
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Expected O, but got Unknown
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Expected O, but got Unknown
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Expected O, but got Unknown
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Expected O, but got Unknown
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Expected O, but got Unknown
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Expected O, but got Unknown
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_026e: Expected O, but got Unknown
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b9: Expected O, but got Unknown
			//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e7: Expected O, but got Unknown
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0315: Expected O, but got Unknown
			//IL_0343: Unknown result type (might be due to invalid IL or missing references)
			//IL_034e: Expected O, but got Unknown
			//IL_0391: Unknown result type (might be due to invalid IL or missing references)
			//IL_039c: Expected O, but got Unknown
			//IL_03df: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ea: Expected O, but got Unknown
			//IL_0418: Unknown result type (might be due to invalid IL or missing references)
			//IL_0423: Expected O, but got Unknown
			//IL_0466: Unknown result type (might be due to invalid IL or missing references)
			//IL_0471: Expected O, but got Unknown
			//IL_04b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bf: Expected O, but got Unknown
			//IL_0556: Unknown result type (might be due to invalid IL or missing references)
			//IL_0561: Expected O, but got Unknown
			//IL_05a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05af: Expected O, but got Unknown
			//IL_05c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0627: Unknown result type (might be due to invalid IL or missing references)
			//IL_065b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0699: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a4: Expected O, but got Unknown
			//IL_06d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_06dd: Expected O, but got Unknown
			//IL_070b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0716: Expected O, but got Unknown
			//IL_0756: Unknown result type (might be due to invalid IL or missing references)
			//IL_0794: Unknown result type (might be due to invalid IL or missing references)
			//IL_079f: Expected O, but got Unknown
			//IL_07cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d8: Expected O, but got Unknown
			//IL_0806: Unknown result type (might be due to invalid IL or missing references)
			//IL_0811: Expected O, but got Unknown
			//IL_0835: Unknown result type (might be due to invalid IL or missing references)
			//IL_0884: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_08e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0920: Unknown result type (might be due to invalid IL or missing references)
			//IL_092b: Expected O, but got Unknown
			_terrainSupport = plugin.config("03 - Blueprint", "Terrain Support", BlueprintTerrainSupportMode.Off, "Controls native blueprint terrain support. Off only places WearNTear. On restores saved terrain support contacts for everyone. AdminDebug restores terrain support only when the placing player is admin and has debug/no-cost build enabled.");
			_chestRows = plugin.config("03 - Blueprint", "Blueprint Chest Rows", 20, new ConfigDescription("Inventory rows for the Homestead blueprint chest. Width is always 8 columns.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(10, 40), Array.Empty<object>()));
			_chestConfirmHotkey = plugin.config<KeyboardShortcut>("03 - Blueprint", "Blueprint Chest Confirm Hotkey", new KeyboardShortcut((KeyCode)101, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }), "Client-only hotkey for confirming a Homestead blueprint chest. The default is Alt+E.", synchronizedSetting: false);
			_azuCraftyBoxesPullMode = plugin.config("03 - Blueprint", "AzuCraftyBoxes Pull Mode", BlueprintAzuCraftyBoxesPullMode.ConfirmOnly, "If AzuCraftyBoxes is installed, pulls missing blueprint materials from nearby allowed containers. ConfirmOnly pulls when confirming the blueprint. OpenAndConfirm also pulls before opening the blueprint chest.");
			_terrainSupportContactTolerance = plugin.config("03 - Blueprint", "Blueprint Terrain Support Contact Tolerance", 0.5f, new ConfigDescription("How close terrain must be to the lowest WearNTear bottom at a 1m x/z cell to be saved as a blueprint terrain support contact.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.01f, 2f), Array.Empty<object>()));
			_terrainSupportFeatherWidth = plugin.config("03 - Blueprint", "Blueprint Terrain Support Feather Width", 6f, new ConfigDescription("Meters around blueprint terrain support contact footprints that blend back to native terrain. Set to 0 to only change exact contact cells.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 64f), Array.Empty<object>()));
			_maxUploadKb = plugin.config("03 - Blueprint", "Max Blueprint Upload KB", 2048, new ConfigDescription("Server-synced maximum uncompressed YAML size for a client blueprint upload. This is checked before YAML deserialization.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(64, 16384), Array.Empty<object>()));
			_maxEntries = plugin.config("03 - Blueprint", "Max Blueprint Entries", 5000, new ConfigDescription("Server-synced maximum WearNTear entries accepted in one Homestead blueprint upload.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 20000), Array.Empty<object>()));
			_maxPreviewEntries = plugin.config("03 - Blueprint", "Max Blueprint Preview Entries", 5000, new ConfigDescription("Server-synced maximum WearNTear entries returned in preview-only blueprint payloads.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 20000), Array.Empty<object>()));
			_maxIconKb = plugin.config("04 - Blueprint Store", "Max Blueprint Store Icon KB", 256, new ConfigDescription("Server-synced maximum decoded PNG size accepted for blueprint store listing icons. Set to 0 to reject uploaded store icons.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 2048), Array.Empty<object>()));
			_storeListingDays = plugin.config("04 - Blueprint Store", "Blueprint Store Listing Days", 0, new ConfigDescription("How many days a blueprint store listing stays visible from the time it is listed before the server can automatically hide it. Set to 0 to disable automatic delisting.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 365), Array.Empty<object>()));
			_storeAutoDelistMaxPurchases = plugin.config("04 - Blueprint Store", "Blueprint Store Auto Delist Max Purchases", 0, new ConfigDescription("Only listings with this many purchases or fewer are automatically hidden after Blueprint Store Listing Days. Default 0 means only listings with no purchases are auto-delisted.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100000), Array.Empty<object>()));
			_storeMaxListingsPerSteamId = plugin.config("04 - Blueprint Store", "Blueprint Store Max Listings Per SteamID", 10, new ConfigDescription("Server-synced maximum active blueprint store listings allowed for one SteamID/platform identity.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 200), Array.Empty<object>()));
			_storeIdentityMode = plugin.config("04 - Blueprint Store", "Blueprint Store Identity Mode", BlueprintStoreIdentityMode.PlayerId, "Controls how Blueprint Store ownership and offer buyer permissions are matched. PlayerId treats each Valheim character separately. SteamId treats every character on the same Steam/platform account as the same store identity.");
			_chestTimeoutMinutes = plugin.config("03 - Blueprint", "Blueprint Chest Timeout Minutes", 30, new ConfigDescription("Minutes since last interaction before empty Homestead blueprint/build/store chests are removed. Set to 0 to disable automatic chest cleanup. A chest is kept while it has visible items, absorbed materials, price items, purchase deposits, or payout contents.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 60), Array.Empty<object>()));
			_chestMapIconSize = plugin.config("03 - Blueprint", "Blueprint Chest Map Icon Size", 1, new ConfigDescription("Client-only icon size for your Homestead blueprint/build/store chests on the large map. Set to 0 to hide these map icons.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 10), Array.Empty<object>()), synchronizedSetting: false);
			_maxActiveChestsPerPlayer = plugin.config("03 - Blueprint", "Max Active Blueprint Chests Per SteamID", 5, new ConfigDescription("Maximum active Homestead blueprint/build/store chests per Steam/platform identity. Set to 0 to disable this limit. If a platform identity cannot be resolved, Homestead falls back to the Valheim playerID.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 50), Array.Empty<object>()));
			_storeLargePanelScale = plugin.config("04 - Blueprint Store", "Blueprint Store Large Panel Scale", 1.5f, new ConfigDescription("Client-only scale multiplier shared by the Blueprint Store listing and offers panels.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.75f, 2f), Array.Empty<object>()), synchronizedSetting: false);
			_storeLargePanelX = plugin.config("04 - Blueprint Store", "Blueprint Store Large Panel X Offset", 0f, new ConfigDescription("Hidden client-only X offset from screen center for the Blueprint Store listing and offers panels. Use the in-game panel drag instead of editing this manually.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-2000f, 2000f), new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Browsable = false
				}
			}), synchronizedSetting: false);
			_storeLargePanelY = plugin.config("04 - Blueprint Store", "Blueprint Store Large Panel Y Offset", 0f, new ConfigDescription("Hidden client-only Y offset from screen center for the Blueprint Store listing and offers panels. Use the in-game panel drag instead of editing this manually.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-2000f, 2000f), new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Browsable = false
				}
			}), synchronizedSetting: false);
			_storeFormPanelScale = plugin.config("04 - Blueprint Store", "Blueprint Store Form Panel Scale", 1.5f, new ConfigDescription("Client-only scale multiplier shared by Blueprint Store offer, edit price, and price chest editor panels.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.75f, 2f), Array.Empty<object>()), synchronizedSetting: false);
			_storeFormPanelX = plugin.config("04 - Blueprint Store", "Blueprint Store Form Panel X Offset", 0f, new ConfigDescription("Hidden client-only X offset from screen center for Blueprint Store form panels. Use the in-game panel drag instead of editing this manually.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-2000f, 2000f), new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Browsable = false
				}
			}), synchronizedSetting: false);
			_storeFormPanelY = plugin.config("04 - Blueprint Store", "Blueprint Store Form Panel Y Offset", 0f, new ConfigDescription("Hidden client-only Y offset from screen center for Blueprint Store form panels. Use the in-game panel drag instead of editing this manually.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-2000f, 2000f), new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Browsable = false
				}
			}), synchronizedSetting: false);
			_storeNotificationMode = plugin.config("04 - Blueprint Store", "Blueprint Store Notification Mode", BlueprintStoreNotificationMode.BadgeOnly, "Client-only display mode for Blueprint Store notifications. Off hides the notification button and disables fallback polling. BadgeOnly keeps the button and unread count visible without opening the panel automatically. AutoOpenPanel opens the notification panel when a new unread notification arrives.", synchronizedSetting: false);
			_storeAnonymousNotifications = plugin.config("04 - Blueprint Store", "Blueprint Store Anonymous Notifications", HomesteadPlugin.Toggle.Off, "Server-synced toggle for hiding player names in Blueprint Store notification messages. When on, notifications say Anonymous instead of the buyer, seller, or offer creator name.");
			_storeDebugLogging = plugin.config("04 - Blueprint Store", "Blueprint Store Debug Logging", HomesteadPlugin.Toggle.Off, "Client-only debug logging for Blueprint Store listing identity and button state. Enable when checking why a listing shows Edit/Buy/Offer/Hide for the current character.", synchronizedSetting: false);
			_storeNotificationButtonX = plugin.config("04 - Blueprint Store", "Blueprint Store Notification Button X Offset", -333f, new ConfigDescription("Hidden client-only default/current X offset for the floating Blueprint Store notification button from the top-right screen anchor. Dragging the in-game button also updates this value.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-3000f, 3000f), new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Browsable = false
				}
			}), synchronizedSetting: false);
			_storeNotificationButtonY = plugin.config("04 - Blueprint Store", "Blueprint Store Notification Button Y Offset", -55f, new ConfigDescription("Hidden client-only default/current Y offset for the floating Blueprint Store notification button from the top-right screen anchor. Dragging the in-game button also updates this value.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-3000f, 3000f), new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Browsable = false
				}
			}), synchronizedSetting: false);
			_storeListModifierKey = plugin.config<KeyboardShortcut>("04 - Blueprint Store", "Blueprint Store List Modifier Key", new KeyboardShortcut((KeyCode)308, Array.Empty<KeyCode>()), "Client-only modifier key held while left-clicking a blueprint in the Homestead build tab to place its Blueprint Store price chest. Set to None to use left-click without a modifier.", synchronizedSetting: false);
			_storeBackHotkey = plugin.config<KeyboardShortcut>("04 - Blueprint Store", "Blueprint Store Back Hotkey", new KeyboardShortcut((KeyCode)326, Array.Empty<KeyCode>()), "Client-only hotkey for returning from Blueprint Store sub-panels such as the offers view. Display uses the same Unity key names as Config Manager.", synchronizedSetting: false);
			_storeListingPreviewColor = plugin.config<Color>("04 - Blueprint Store", "Store Listing Pending Preview Color", new Color(1f, 0.9f, 0.2f, 0.15f), "Client-only color used for a blueprint preview after its store listing price chest has been placed but before the listing is confirmed. Alpha comes from this color's A value.", synchronizedSetting: false);
			_storePurchasePreviewColor = plugin.config<Color>("04 - Blueprint Store", "Store Purchase Pending Preview Color", new Color(1f, 0.54f, 0.12f, 0.15f), "Client-only color used for a blueprint preview after its purchase chest has been placed but before payment is confirmed. Alpha comes from this color's A value.", synchronizedSetting: false);
			_areaSaveMaxSide = plugin.config("03 - Blueprint", "Area Save Max Side Length", 64f, new ConfigDescription("Server-synced maximum side length in meters for the hammer Area Save blueprint rectangle.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(2f, 256f), Array.Empty<object>()));
			_areaSaveDefaultWidth = plugin.config("03 - Blueprint", "Area Save Default Width", 8f, new ConfigDescription("Client-only default Area Save rectangle width. This is clamped by the server max side length.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(2f, 256f), Array.Empty<object>()), synchronizedSetting: false);
			_areaSaveDefaultDepth = plugin.config("03 - Blueprint", "Area Save Default Depth", 8f, new ConfigDescription("Client-only default Area Save rectangle depth. Set a different value from width to start as a rectangle.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(2f, 256f), Array.Empty<object>()), synchronizedSetting: false);
			_areaSaveCreatorMode = plugin.config("03 - Blueprint", "Area Save Creator Mode", BlueprintAreaSaveCreatorMode.OwnedAndCreatorless, "Controls which WearNTear objects the Area Save tool can select. AllCreators saves your own, creator=0, and other creators' WearNTear. OwnedAndCreatorless saves your own plus creator=0 WearNTear. OwnedOnly saves only WearNTear with your playerID.");
			_areaSaveBoundaryColor = plugin.config<Color>("03 - Blueprint", "Area Save Boundary Color", new Color(1f, 0.9f, 0.2f, 0.9f), "Client-only color for the Area Save rectangle line.", synchronizedSetting: false);
			_areaDismantleMaxSide = plugin.config("03 - Blueprint", "Area Dismantle Max Side Length", 8f, new ConfigDescription("Server-synced maximum side length in meters for the hammer Area Dismantle rectangle.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 128f), Array.Empty<object>()));
			_areaDismantleDefaultWidth = plugin.config("03 - Blueprint", "Area Dismantle Default Width", 4f, new ConfigDescription("Client-only default Area Dismantle rectangle width. This is clamped by the server max side length.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 128f), Array.Empty<object>()), synchronizedSetting: false);
			_areaDismantleDefaultDepth = plugin.config("03 - Blueprint", "Area Dismantle Default Depth", 4f, new ConfigDescription("Client-only default Area Dismantle rectangle depth. Set a different value from width to start as a rectangle.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 128f), Array.Empty<object>()), synchronizedSetting: false);
			_areaDismantleBoundaryColor = plugin.config<Color>("03 - Blueprint", "Area Dismantle Boundary Color", new Color(1f, 0.3f, 0.12f, 0.9f), "Client-only color for the Area Dismantle rectangle line.", synchronizedSetting: false);
			_areaDismantlePrefabBlacklist = plugin.config("03 - Blueprint", "Area Dismantle Prefab Blacklist", "piece_stuward", "Comma-separated additional prefab names that Area Dismantle will never dismantle. Homestead blueprint/store chests are always protected internally.");
			PruneBuiltInAreaDismantleBlacklistEntries();
			_areaToolDepthModifierKey = plugin.config<KeyboardShortcut>("03 - Blueprint", "Area Tool Depth Modifier Key", new KeyboardShortcut((KeyCode)326, Array.Empty<KeyCode>()), "Client-only modifier key held while using the mouse wheel to resize only the depth of Area Save and Area Dismantle rectangles. Set to None to disable depth-only wheel resizing.", synchronizedSetting: false);
			_areaToolWidthModifierKey = plugin.config<KeyboardShortcut>("03 - Blueprint", "Area Tool Width Modifier Key", new KeyboardShortcut((KeyCode)327, Array.Empty<KeyCode>()), "Client-only modifier key held while using the mouse wheel to resize only the width of Area Save and Area Dismantle rectangles. Set to None to disable width-only wheel resizing.", synchronizedSetting: false);
			_previewGhostColor = plugin.config<Color>("03 - Blueprint", "Preview Ghost Color", new Color(0.35f, 0.75f, 1f, 0.15f), "Client-only color for unfinished blueprint preview pieces.", synchronizedSetting: false);
			_previewGhostBrightness = plugin.config("03 - Blueprint", "Preview Ghost Brightness", 0.8f, new ConfigDescription("Client-only brightness multiplier for unfinished blueprint preview pieces.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 2f), Array.Empty<object>()), synchronizedSetting: false);
		}

		private static bool IsAdminDebugPlayer(Player player)
		{
			if ((Object)(object)player != (Object)null && player.NoCostCheat())
			{
				return IsAdminPlayer(player);
			}
			return false;
		}

		private static bool IsAdminPlayer(Player player)
		{
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ZNet.instance == (Object)null || (Object)(object)player == (Object)null)
			{
				return false;
			}
			if ((Object)(object)player == (Object)(object)Player.m_localPlayer)
			{
				return ZNet.instance.LocalPlayerIsAdminOrHost();
			}
			if (ZDOMan.instance == null)
			{
				return false;
			}
			long playerID = player.GetPlayerID();
			if (playerID == 0L)
			{
				return false;
			}
			foreach (ZNetPeer peer in ZNet.instance.m_peers)
			{
				if (peer == null || !peer.IsReady() || ((ZDOID)(ref peer.m_characterID)).IsNone())
				{
					continue;
				}
				ZDO zDO = ZDOMan.instance.GetZDO(peer.m_characterID);
				if (zDO != null && zDO.GetLong(ZDOVars.s_playerID, 0L) == playerID)
				{
					ZRpc rpc = peer.m_rpc;
					object obj;
					if (rpc == null)
					{
						obj = null;
					}
					else
					{
						ISocket socket = rpc.m_socket;
						obj = ((socket != null) ? socket.GetHostName() : null);
					}
					if (obj == null)
					{
						obj = "";
					}
					string text = (string)obj;
					return text.Length > 0 && ZNet.instance.IsAdmin(text);
				}
			}
			return false;
		}

		private static void PruneBuiltInAreaDismantleBlacklistEntries()
		{
			List<string> list = (from entry in (_areaDismantlePrefabBlacklist.Value ?? "").Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries)
				select entry.Trim() into entry
				where !string.IsNullOrWhiteSpace(entry)
				select entry).ToList();
			List<string> list2 = list.Where((string entry) => !BuiltInAreaDismantleProtectedPrefabs.Contains(entry)).Distinct<string>(StringComparer.OrdinalIgnoreCase).ToList();
			if (list2.Count != list.Count || !list2.SequenceEqual<string>(list, StringComparer.OrdinalIgnoreCase))
			{
				_areaDismantlePrefabBlacklist.Value = string.Join(",", list2);
			}
		}

		private static Color GetStorePendingPreviewColor(Color value, Color fallback)
		{
			//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_001e: 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_0046: 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_006a: Unknown result type (might be due to invalid IL or missing references)
			Color val = value;
			float num = Mathf.Clamp(_previewGhostBrightness.Value, 0.1f, 2f);
			val.r = Mathf.Clamp01(val.r * num);
			val.g = Mathf.Clamp01(val.g * num);
			val.b = Mathf.Clamp01(val.b * num);
			val.a = Mathf.Clamp01(val.a);
			return val;
		}
	}
	internal static class BuildCameraConfig
	{
		private static ConfigEntry<HomesteadPlugin.Toggle> _enabled;

		private static ConfigEntry<float> _resourcePickupRange;

		private static ConfigEntry<BuildCameraDistanceMode> _distanceMode;

		private static ConfigEntry<float> _maxDistanceFromAvatar;

		private static ConfigEntry<float> _baseDistanceFromAvatar;

		private static ConfigEntry<float> _distancePerComfortLevel;

		private static ConfigEntry<float> _moveSpeedMultiplier;

		private static ConfigEntry<KeyboardShortcut> _toggleHotkey;

		private static ConfigEntry<HomesteadPlugin.Toggle> _demisterFollowCamera;

		private static ConfigEntry<KeyboardShortcut> _lookAtLockHotkey;

		private static ConfigEntry<BuildCameraRestrictionMode> _restrictionMode;

		private static ConfigEntry<int> _minimumComfortLevel;

		private static ConfigEntry<HomesteadPlugin.Toggle> _followDvergrCircletLight;

		private static ConfigEntry<float> _helmetLightOffsetForward;

		private static ConfigEntry<float> _helmetLightOffsetUp;

		public static bool Enabled => _enabled.Value.IsOn();

		public static float ResourcePickupRange => Mathf.Clamp(_resourcePickupRange.Value, 0f, 100f);

		public static BuildCameraDistanceMode DistanceMode => _distanceMode.Value;

		public static float MaxDistanceFromAvatar => Mathf.Clamp(_maxDistanceFromAvatar.Value, 1f, 500f);

		public static float BaseDistanceFromAvatar => Mathf.Clamp(_baseDistanceFromAvatar.Value, 1f, 500f);

		public static float DistancePerComfortLevel => Mathf.Clamp(_distancePerComfortLevel.Value, 0f, 50f);

		public static float MoveSpeedMultiplier => Mathf.Clamp(_moveSpeedMultiplier.Value, 0.1f, 20f);

		public static KeyboardShortcut ToggleHotkey => _toggleHotkey.Value;

		public static bool DemisterFollowCamera => _demisterFollowCamera.Value.IsOn();

		public static KeyboardShortcut LookAtLockHotkey => _lookAtLockHotkey.Value;

		public static BuildCameraRestrictionMode RestrictionMode => _restrictionMode.Value;

		public static int MinimumComfortLevel => Mathf.Clamp(_minimumComfortLevel.Value, 1, 30);

		public static bool FollowDvergrCircletLight => _followDvergrCircletLight.Value.IsOn();

		public static float HelmetLightOffsetForward => Mathf.Clamp(_helmetLightOffsetForward.Value, -5f, 5f);

		public static float HelmetLightOffsetUp => Mathf.Clamp(_helmetLightOffsetUp.Value, -5f, 5f);

		public static void Bind(HomesteadPlugin plugin)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Expected O, but got Unknown
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Expected O, but got Unknown
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Expected O, but got Unknown
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Expected O, but got Unknown
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Expected O, but got Unknown
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Expected O, but got Unknown
			//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Expected O, but got Unknown
			_enabled = plugin.config("05 - Build Camera", "Enabled", HomesteadPlugin.Toggle.On, new ConfigDescription("If on, Homestead includes BuildCameraCHE-style free build camera mode. Disable this if the standalone BuildCameraCHE mod is installed.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 1000
				}
			}));
			_resourcePickupRange = plugin.config("05 - Build Camera", "Resource Pickup Range", 10f, new ConfigDescription("Distance from which build camera mode can pick up resources on the ground. Valheim default is 2.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 100f), Array.Empty<object>()));
			_distanceMode = plugin.config("05 - Build Camera", "Camera Distance Mode", BuildCameraDistanceMode.ComfortScaled, "Fixed: use Camera Distance(Max) In Fixed Mode. ComfortScaled: use Base Camera Distance From Avatar + current comfort level * Camera Distance Per Comfort Level.");
			_maxDistanceFromAvatar = plugin.config("05 - Build Camera", "Camera Distance(Max) In Fixed Mode", 32f, new ConfigDescription("Fixed build camera distance in meters when Camera Distance Mode is Fixed.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 500f), Array.Empty<object>()));
			_baseDistanceFromAvatar = plugin.config("05 - Build Camera", "Base Camera Distance From Avatar", 32f, new ConfigDescription("Base distance in meters that the build camera can move away from your player avatar before comfort scaling is added.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 500f), Array.Empty<object>()));
			_distancePerComfortLevel = plugin.config("05 - Build Camera", "Camera Distance Per Comfort Level", 2f, new ConfigDescription("Extra build camera distance in meters added for each current comfort level.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 50f), Array.Empty<object>()));
			_moveSpeedMultiplier = plugin.config("05 - Build Camera", "Camera Move Speed Multiplier", 3f, new ConfigDescription("Multiplies build camera panning speed.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 20f), Array.Empty<object>()));
			_toggleHotkey = plugin.config<KeyboardShortcut>("05 - Build Camera", "Toggle Build Camera Hotkey", new KeyboardShortcut((KeyCode)98, Array.Empty<KeyCode>()), "Client-only hotkey that toggles build camera mode while a build tool is equipped.", synchronizedSetting: false);
			_demisterFollowCamera = plugin.config("05 - Build Camera", "Demister Follow Camera", HomesteadPlugin.Toggle.On, "If on, the Wisplight demister ball follows the build camera while build camera mode is active.");
			_lookAtLockHotkey = plugin.config<KeyboardShortcut>("05 - Build Camera", "Look At Lock Hotkey", new KeyboardShortcut((KeyCode)113, Array.Empty<KeyCode>()), "Client-only hotkey that toggles build camera look-at lock while build camera mode is active.", synchronizedSetting: false);
			_restrictionMode = plugin.config("05 - Build Camera", "Restriction Mode", BuildCameraRestrictionMode.Off, "Off: no cozy restriction. CameraNeedsCoziness: cozy required to enter and stay in build camera. CameraPickUpNeedsCoziness: camera entry is allowed, but camera item pickup requires cozy.");
			_minimumComfortLevel = plugin.config("05 - Build Camera", "Restriction Mode Minimum Comfort Level", 1, new ConfigDescription("Minimum comfort level required by the build camera comfort restriction.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 30), Array.Empty<object>()));
			_followDvergrCircletLight = plugin.config("05 - Build Camera", "Dvergr Circlet Light Follow Camera", HomesteadPlugin.Toggle.On, "If on, Dvergr circlet light follows the build camera while build camera mode is active.");
			_helmetLightOffsetForward = plugin.config("05 - Build Camera", "Dvergr Circlet Light Forward Offset", 0.65f, new ConfigDescription("Client-only Dvergr circlet light offset along the build camera forward axis.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-5f, 5f), Array.Empty<object>()), synchronizedSetting: false);
			_helmetLightOffsetUp = plugin.config("05 - Build Camera", "Dvergr Circlet Light Up Offset", -0.08f, new ConfigDescription("Client-only Dvergr circlet light offset along the build camera up axis.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-5f, 5f), Array.Empty<object>()), synchronizedSetting: false);
		}
	}
	internal static class PlacementControlConfig
	{
		private static ConfigEntry<KeyboardShortcut> _gridSnapToggleHotkey;

		private static ConfigEntry<float> _gridSnapSize;

		private static ConfigEntry<HomesteadPlugin.Toggle> _placementAdjustEnabled;

		private static ConfigEntry<float> _placementAdjustHeightStep;

		private static ConfigEntry<float> _placementAdjustHorizontalStep;

		private static ConfigEntry<float> _placementRotationStep;

		private static ConfigEntry<float> _placementXAxisRotation;

		private static ConfigEntry<float> _placementZAxisRotation;

		private static ConfigEntry<KeyboardShortcut> _placementAdjustModifierKey;

		public static KeyboardShortcut GridSnapToggleHotkey => _gridSnapToggleHotkey.Value;

		public static float GridSnapSize => Mathf.Round(Mathf.Clamp(_gridSnapSize.Value, 0.05f, 1f) * 20f) / 20f;

		public static bool PlacementAdjustEnabled => _placementAdjustEnabled.Value.IsOn();

		public static float HeightStep => Mathf.Clamp(_placementAdjustHeightStep.Value, 0.01f, 10f);

		public static float HorizontalStep => Mathf.Clamp(_placementAdjustHorizontalStep.Value, 0.01f, 10f);

		public static float RotationStep => Mathf.Clamp(_placementRotationStep.Value, 1f, 90f);

		public static float XAxisRotation => Mathf.Clamp(_placementXAxisRotation.Value, -180f, 180f);

		public static float ZAxisRotation => Mathf.Clamp(_placementZAxisRotation.Value, -180f, 180f);

		public static bool HasPlacementAxisRotation
		{
			get
			{
				if (!(Mathf.Abs(XAxisRotation) > 0.001f))
				{
					return Mathf.Abs(ZAxisRotation) > 0.001f;
				}
				return true;
			}
		}

		public static KeyboardShortcut PlacementAdjustModifierKey => _placementAdjustModifierKey.Value;

		public static string PlacementAdjustModifierLabel => ConfigValueHelpers.FormatShortcut(PlacementAdjustModifierKey);

		public static string AreaUniformScaleInputLabel
		{
			get
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				KeyboardShortcut placementAdjustModifierKey = PlacementAdjustModifierKey;
				if ((int)((KeyboardShortcut)(ref placementAdjustModifierKey)).MainKey != 0)
				{
					return PlacementAdjustModifierLabel + "+Wheel";
				}
				return "";
			}
		}

		public static bool IsAreaDepthModifierHeld()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return ConfigValueHelpers.IsShortcutHeld(BlueprintConfig.AreaToolDepthModifierKey, allowUnbound: false);
		}

		public static bool IsAreaWidthModifierHeld()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return ConfigValueHelpers.IsShortcutHeld(BlueprintConfig.AreaToolWidthModifierKey, allowUnbound: false);
		}

		public static bool IsAreaUniformScaleModifierHeld()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: 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)
			KeyboardShortcut placementAdjustModifierKey = PlacementAdjustModifierKey;
			if ((int)((KeyboardShortcut)(ref placementAdjustModifierKey)).MainKey != 0)
			{
				return ConfigValueHelpers.IsShortcutHeld(PlacementAdjustModifierKey, allowUnbound: false);
			}
			return false;
		}

		public static bool IsPlacementAdjustModifierHeld()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return ConfigValueHelpers.IsShortcutHeld(PlacementAdjustModifierKey, allowUnbound: true);
		}

		public static void Bind(HomesteadPlugin plugin)
		{
			//IL_0012: 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_005b: 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
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Expected O, but got Unknown
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Expected O, but got Unknown
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Expected O, but got Unknown
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Expected O, but got Unknown
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			_gridSnapToggleHotkey = plugin.config<KeyboardShortcut>("06 - Placement Controls", "Grid Snap Toggle Hotkey", new KeyboardShortcut((KeyCode)103, Array.Empty<KeyCode>()), "Client-only hotkey that toggles grid snapping on or off while placing build pieces. The default is G.", synchronizedSetting: false);
			_gridSnapSize = plugin.config("06 - Placement Controls", "Grid Size", 0.5f, new ConfigDescription("Client-only grid spacing in meters. Values are clamped and rounded to 0.05m steps between 0.05 and 1.0.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.05f, 1f), Array.Empty<object>()), synchronizedSetting: false);
			_placementAdjustEnabled = plugin.config("06 - Placement Controls", "Position Adjust", HomesteadPlugin.Toggle.On, "If on, hammer pieces, Homestead blueprints, and area tools can be nudged with PgUp/PgDn and arrow keys.");
			_placementAdjustHeightStep = plugin.config("06 - Placement Controls", "Position Height Step", 0.5f, new ConfigDescription("Client-only vertical offset step in meters for PgUp/PgDn while adjusting placement.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.01f, 10f), Array.Empty<object>()), synchronizedSetting: false);
			_placementAdjustHorizontalStep = plugin.config("06 - Placement Controls", "Position Horizontal Step", 0.5f, new ConfigDescription("Client-only horizontal offset step in meters for arrow keys while adjusting placement.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.01f, 10f), Array.Empty<object>()), synchronizedSetting: false);
			_placementRotationStep = plugin.config("06 - Placement Controls", "Rotation Step", 22.5f, new ConfigDescription("Client-only rotation step in degrees shared by Area Save, Area Dismantle, blueprint yaw rotation, and placement rotation controls.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 90f), Array.Empty<object>()), synchronizedSetting: false);
			_placementXAxisRotation = plugin.config("06 - Placement Controls", "X Axis Rotation", 0f, new ConfigDescription("Client-only default X-axis rotation in degrees applied to ordinary hammer build piece previews and final placement. Terrain tools and Homestead area tools are ignored.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-180f, 180f), Array.Empty<object>()), synchronizedSetting: false);
			_placementZAxisRotation = plugin.config("06 - Placement Controls", "Z Axis Rotation", 0f, new ConfigDescription("Client-only default Z-axis rotation in degrees applied to ordinary hammer build piece previews and final placement. Terrain tools and Homestead area tools are ignored.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-180f, 180f), Array.Empty<object>()), synchronizedSetting: false);
			_placementAdjustModifierKey = plugin.config<KeyboardShortcut>("06 - Placement Controls", "Position Adjust Modifier Key", new KeyboardShortcut((KeyCode)308, Array.Empty<KeyCode>()), "Client-only modifier key held while using PgUp/PgDn and arrow keys for placement offsets. Set to None to allow the old unmodified keys.", synchronizedSetting: false);
		}
	}
	internal static class DvergrCircletConfig
	{
		public const float MaxDurability = 100f;

		public const float PerItemMinMultiplier = 1f;

		private static ConfigEntry<HomesteadPlugin.Toggle> _extensionEnabled;

		private static ConfigEntry<float> _fuelMinutes;

		private static ConfigEntry<string> _repairStation;

		private static ConfigEntry<float> _perItemMaxIntensityMultiplier;

		private static ConfigEntry<float> _perItemMaxRangeMultiplier;

		private static ConfigEntry<float> _perItemAdjustmentStep;

		private static ConfigEntry<KeyboardShortcut> _toggleLightHotkey;

		private static ConfigEntry<KeyboardShortcut> _adjustmentModifierKey;

		private static ConfigEntry<HomesteadPlugin.Toggle> _remoteVisualSync;

		private static ConfigEntry<float> _remoteLightMaxDistance;

		private static ConfigEntry<HomesteadPlugin.Toggle> _debugLogging;

		public static bool ExtensionEnabled => _extensionEnabled.Value.IsOn();

		public static float FuelSeconds => Mathf.Max(1f, _fuelMinutes.Value) * 60f;

		public static string RepairStation
		{
			get
			{
				if (!string.IsNullOrWhiteSpace(_repairStation.Value))
				{
					return _repairStation.Value.Trim();
				}
				return "forge";
			}
		}

		public static float PerItemMaxIntensityMultiplier => Mathf.Max(1f, Mathf.Clamp(_perItemMaxIntensityMultiplier.Value, 1f, 3f));

		public static float PerItemMaxRangeMultiplier => Mathf.Max(1f, Mathf.Clamp(_perItemMaxRangeMultiplier.Value, 1f, 3f));

		public static float PerItemAdjustmentStep => Mathf.Clamp(_perItemAdjustmentStep.Value, 0.05f, 1f);

		public static KeyboardShortcut ToggleLightHotkey => _toggleLightHotkey.Value;

		public static KeyboardShortcut AdjustmentModifierKey => _adjustmentModifierKey.Value;

		public static string AdjustmentModifierLabel => ConfigValueHelpers.FormatShortcut(AdjustmentModifierKey);

		public static bool RemoteVisualSync => _remoteVisualSync.Value.IsOn();

		public static float RemoteLightMaxDistance => Mathf.Clamp(_remoteLightMaxDistance.Value, 0f, 200f);

		public static bool DebugLogging => _debugLogging.Value.IsOn();

		public static void Bind(HomesteadPlugin plugin)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Expected O, but got Unknown
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Expected O, but got Unknown
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Expected O, but got Unknown
			//IL_0156: 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)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Expected O, but got Unknown
			_extensionEnabled = plugin.config("08 - Dvergr Circlet", "Enabled", HomesteadPlugin.Toggle.On, new ConfigDescription("If on, Homestead gives the Dvergr circlet per-item configurable light range, light intensity, durability drain while lit, and custom repair station support. If Circlet Extended is installed, Homestead leaves circlet handling to that mod.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 1000
				}
			}));
			_fuelMinutes = plugin.config("08 - Dvergr Circlet", "Base Fuel Minutes", 60f, new ConfigDescription("How many minutes a full Dvergr circlet lasts at 1.0 light intensity and 1.0 light range. Higher intensity and range drain proportionally faster.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 10000f), Array.Empty<object>()));
			_repairStation = plugin.config("08 - Dvergr Circlet", "Repair Station", "forge", "Crafting station required to repair the Dvergr circlet. Use the prefab name like forge, workbench, blackforge, or the localized station token like $piece_forge.");
			_perItemMaxIntensityMultiplier = plugin.config("08 - Dvergr Circlet", "Maximum Intensity Multiplier", 3f, new ConfigDescription("Highest brightness multiplier a player can set on an individual Dvergr circlet with hotkeys.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 3f), Array.Empty<object>()));
			_perItemMaxRangeMultiplier = plugin.config("08 - Dvergr Circlet", "Maximum Range Multiplier", 3f, new ConfigDescription("Highest range multiplier a player can set on an individual Dvergr circlet with hotkeys.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 3f), Array.Empty<object>()));
			_perItemAdjustmentStep = plugin.config("08 - Dvergr Circlet", "Adjustment Step", 0.5f, new ConfigDescription("Brightness/range multiplier step used by Dvergr circlet hotkeys. 0.5 means 50% per key press.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.05f, 1f), Array.Empty<object>()));
			_toggleLightHotkey = plugin.config<KeyboardShortcut>("08 - Dvergr Circlet", "Toggle Light Hotkey", new KeyboardShortcut((KeyCode)108, Array.Empty<KeyCode>()), "Client-only hotkey that toggles the equipped Dvergr circlet light on or off.", synchronizedSetting: false);
			_adjustmentModifierKey = plugin.config<KeyboardShortcut>("08 - Dvergr Circlet", "Adjustment Modifier Key", new KeyboardShortcut((KeyCode)304, Array.Empty<KeyCode>()), "Client-only modifier held while using fixed arrow keys to adjust the equipped Dvergr circlet. Up/Down changes brightness, Right/Left changes range. Set to None to use arrow keys without a modifier.", synchronizedSetting: false);
			_remoteVisualSync = plugin.config("08 - Dvergr Circlet", "Remote Visual Sync", HomesteadPlugin.Toggle.On, "If on, Homestead publishes Dvergr circlet custom-slot visual state through the player ZDO so other clients can see the circlet visual and light. Disable only if another mod owns circlet visuals.");
			_remoteLightMaxDistance = plugin.config("08 - Dvergr Circlet", "Remote Light Max Distance", 60f, new ConfigDescription("Client-only maximum distance in meters for rendering Homestead-synced remote Dvergr circlet lights. Set to 0 for no distance culling.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 200f), Array.Empty<object>()), synchronizedSetting: false);
			_debugLogging = plugin.config("08 - Dvergr Circlet", "Debug Logging", HomesteadPlugin.Toggle.Off, "Client-only diagnostic logging for Dvergr circlet equip detection, AzuExtended custom slot detection, visual roots, remote sync, and fallback light state.", synchronizedSetting: false);
		}
	}
	internal static class AreaToolConfig
	{
		public static float BlueprintSaveMaxSide => BlueprintConfig.AreaSaveMaxSide;

		public static float BlueprintSaveDefaultWidth => BlueprintConfig.AreaSaveDefaultWidth;

		public static float BlueprintSaveDefaultDepth => BlueprintConfig.AreaSaveDefaultDepth;

		public static Color BlueprintSaveColor => BlueprintConfig.AreaSaveBoundaryColor;

		public static float DismantleMaxSide => BlueprintConfig.AreaDismantleMaxSide;

		public static float DismantleDefaultWidth => BlueprintConfig.AreaDismantleDefaultWidth;

		public static float DismantleDefaultDepth => BlueprintConfig.AreaDismantleDefaultDepth;

		public static Color DismantleColor => BlueprintConfig.AreaDismantleBoundaryColor;
	}
	internal static class ConfigValueHelpers
	{
		public static HashSet<string> SplitPrefabList(string value)
		{
			return (from item in (value ?? "").Split(new char[4] { ',', ';', '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries)
				select item.Trim() into item
				where item.Length > 0
				select item).ToHashSet<string>(StringComparer.OrdinalIgnoreCase);
		}

		public static bool IsShortcutHeld(KeyboardShortcut shortcut, bool allowUnbound)
		{
			//IL_0002: 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)
			if ((int)((KeyboardShortcut)(ref shortcut)).MainKey == 0)
			{
				return allowUnbound;
			}
			if (IsModifierKeyHeld(((KeyboardShortcut)(ref shortcut)).MainKey))
			{
				return ((KeyboardShortcut)(ref shortcut)).Modifiers.All(IsModifierKeyHeld);
			}
			return false;
		}

		public static bool IsShortcutDown(KeyboardShortcut shortcut)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			if ((int)((KeyboardShortcut)(ref shortcut)).MainKey != 0 && ((KeyboardShortcut)(ref shortcut)).Modifiers.All(IsModifierKeyHeld))
			{
				return IsKeyDown(((KeyboardShortcut)(ref shortcut)).MainKey);
			}
			return false;
		}

		public static string FormatShortcut(KeyboardShortcut shortcut)
		{
			//IL_0002: 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 ((int)((KeyboardShortcut)(ref shortcut)).MainKey == 0)
			{
				return "None";
			}
			List<string> list = (from text in ((KeyboardShortcut)(ref shortcut)).Modifiers.Where((KeyCode key) => (int)key > 0).Select(FormatKeyCode)
				where !string.IsNullOrWhiteSpace(text)
				select text).ToList();
			list.Add(FormatKeyCode(((KeyboardShortcut)(ref shortcut)).MainKey));
			if (list.Count != 0)
			{
				return string.Join("+", list);
			}
			return "None";
		}

		private static string FormatKeyCode(KeyCode key)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			if ((int)key == 0)
			{
				return "";
			}
			return ((object)(KeyCode)(ref key)).ToString().Replace("LeftControl", "Ctrl").Replace("RightControl", "Ctrl")
				.Replace("LeftShift", "Shift")
				.Replace("RightShift", "Shift")
				.Replace("LeftAlt", "Alt")
				.Replace("RightAlt", "Alt");
		}

		private static bool IsModifierKeyHeld(KeyCode key)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: 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_0027: Expected I4, but got Unknown
			//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_004f: Expected I4, but got Unknown
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			if ((int)key != 0)
			{
				switch (key - 303)
				{
				default:
					return (key - 323) switch
					{
						0 => Input.GetMouseButton(0), 
						1 => Input.GetMouseButton(1), 
						2 => Input.GetMouseButton(2), 
						3 => Input.GetMouseButton(3), 
						4 => Input.GetMouseButton(4), 
						5 => Input.GetMouseButton(5), 
						6 => Input.GetMouseButton(6), 
						_ => Input.GetKey(key), 
					};
				case 2:
				case 3:
					return Input.GetKey((KeyCode)306) || Input.GetKey((KeyCode)305);
				case 0:
				case 1:
					return Input.GetKey((KeyCode)304) || Input.GetKey((KeyCode)303);
				case 4:
				case 5:
					return Input.GetKey((KeyCode)308) || Input.GetKey((KeyCode)307);
				}
			}
			return false;
		}

		private static bool IsKeyDown(KeyCode key)
		{
			//IL_0000: 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)
			//IL_0028: Expected I4, but got Unknown
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			return (key - 323) switch
			{
				0 => Input.GetMouseButtonDown(0), 
				1 => Input.GetMouseButtonDown(1), 
				2 => Input.GetMouseButtonDown(2), 
				3 => Input.GetMouseButtonDown(3), 
				4 => Input.GetMouseButtonDown(4), 
				5 => Input.GetMouseButtonDown(5), 
				6 => Input.GetMouseButtonDown(6), 
				_ => Input.GetKeyDown(key), 
			};
		}
	}
	internal sealed class ConfigurationManagerAttributes
	{
		[UsedImplicitly]
		public int? Order;

		[UsedImplicitly]
		public bool? Browsable;

		[UsedImplicitly]
		public string? Category;

		[UsedImplicitly]
		public Action<ConfigEntryBase>? CustomDrawer;
	}
	internal static class HomesteadFeatureBootstrap
	{
		private static Player? _lastLocalPlayer;

		public static void Initialize(ManualLogSource logger, Harmony harmony)
		{
			ZoneSessionResetRegistry.Initialize(logger);
			ZoneBlueprintCommands.Initialize(logger);
			ZoneBlueprintSaveTool.Initialize(logger);
			ZoneAreaDismantleTool.Initialize(logger);
			ZoneBlueprintPlacementTool.Initialize(logger);
			ZoneBlueprintChestVfx.Initialize(logger);
			ZoneBlueprintPlanChestPrefab.Initialize(logger);
			ZoneBlueprintChestZdoRegistry.Initialize(logger);
			ZoneBlueprintChestMapPins.Initialize(logger);
			ZoneBlueprintChestCommands.Initialize(logger);
			ZoneBlueprintStore.Initialize(logger);
			ZoneBuildCamera.Initialize(logger);
			ZoneGridSnap.Initialize(logger);
			ZonePlacementAdjust.Initialize(logger);
			ZoneDvergrCirclet.Initialize(logger);
			RegisterSessionResetters();
			harmony.PatchAll(Assembly.GetExecutingAssembly());
			AzuCraftyBoxesCompat.Initialize(logger, harmony);
			ZoneWorldEditTerrainCompat.Initialize(logger, harmony);
		}

		private static void RegisterSessionResetters()
		{
			ZoneSessionResetRegistry.Register("Blueprint menu", ZoneBlueprintSaveToolMenu.ResetForWorldSession);
			ZoneSessionResetRegistry.Register("Blueprint plan RPC", ZoneBlueprintPlanRpc.ResetForWorldSession);
			ZoneSessionResetRegistry.Register("Blueprint store", ZoneBlueprintStore.ResetForWorldSession);
			ZoneSessionResetRegistry.Register("ContentsWithin preview", ZoneContentsWithinBlueprintChestPreview.ResetForWorldSession);
			ZoneSessionResetRegistry.Register("Dvergr circlet", ZoneDvergrCirclet.ResetForWorldSession);
		}

		public static void Update()
		{
			ZoneBlueprintNetworkPayload.Update();
			ZoneBlueprintChestZdoRegistry.Update();
			ZoneBlueprintChestCommands.RegisterRpcs();
			ZoneBlueprintChestVfx.Update();
			ZoneAreaDismantleTool.RegisterRpcs();
			ZoneBlueprintSaveToolMenu.Update();
			ZoneBlueprintPlanRpc.Update();
			ZoneBlueprintStore.Update();
			ZoneBuildCamera.Update();
			ZoneGridSnap.Update();
			ZoneDvergrCirclet.Update();
			AzuCraftyBoxesCompat.Update();
			ZoneWorldEditTerrainCompat.Update();
		}

		public static void Shutdown()
		{
			ZoneBuildCamera.Shutdown();
			ZoneSessionResetRegistry.ResetForWorldSession("shutdown");
			ZoneBlueprintChestMapPins.Shutdown();
			ZoneBlueprintChestZdoRegistry.Shutdown();
			ZoneBlueprintStoreDraftRepository.Flush(force: true);
		}

		public static void OnLocalPlayerSet()
		{
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null) && !((Object)(object)localPlayer == (Object)(object)_lastLocalPlayer))
			{
				_lastLocalPlayer = localPlayer;
				ZoneSessionResetRegistry.ResetForWorldSession("local player changed");
			}
		}
	}
	internal static class HomesteadLocalization
	{
		private static bool _loaded;

		private static ManualLogSource? _logger;

		public static void Load(ManualLogSource logger)
		{
			_logger = logger;
			if (!_loaded)
			{
				_loaded = true;
				CustomLocalization localization = LocalizationManager.Instance.GetLocalization();
				AddEmbeddedYaml(localization, "English");
				AddEmbeddedYaml(localization, "Korean");
				AddExternalYamlFiles(localization);
			}
		}

		public static string Token(string key)
		{
			if (!key.StartsWith("$", StringComparison.Ordinal))
			{
				return "$" + key;
			}
			return key;
		}

		public static string Text(string key)
		{
			string text = Token(key);
			if (Localization.instance == null)
			{
				return text;
			}
			return Localization.instance.Localize(text);
		}

		public static string Format(string key, params object[] args)
		{
			string text = Text(key);
			try
			{
				return string.Format(CultureInfo.InvariantCulture, text, args);
			}
			catch (FormatException)
			{
				return text;
			}
		}

		public static string MaybeLocalize(string value)
		{
			if (Localization.instance == null)
			{
				return value;
			}
			return Localization.instance.Localize(value);
		}

		private static void AddEmbeddedYaml(CustomLocalization localization, string language)
		{
			string resourceSuffix = ".translations." + language + ".yml";
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			string text = executingAssembly.GetManifestResourceNames().FirstOrDefault((string name) => name.EndsWith(resourceSuffix, StringComparison.Ordinal));
			if (text == null)
			{
				ManualLogSource? logger = _logger;
				if (logger != null)
				{
					logger.LogWarning((object)("Homestead localization resource not found: translations/" + language + ".yml"));
				}
				return;
			}
			using Stream stream = executingAssembly.GetManifestResourceStream(text);
			if (stream == null)
			{
				ManualLogSource? logger2 = _logger;
				if (logger2 != null)
				{
					logger2.LogWarning((object)("Homestead localization resource could not be opened: " + text));
				}
				return;
			}
			using StreamReader streamReader = new StreamReader(stream, Encoding.UTF8);
			localization.AddYamlFile(language, streamReader.ReadToEnd());
		}

		private static void AddExternalYamlFiles(CustomLocalization localization)
		{
			string pluginPath = Paths.PluginPath;
			if (string.IsNullOrWhiteSpace(pluginPath) || !Directory.Exists(pluginPath))
			{
				return;
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			foreach (string item in Directory.EnumerateFiles(pluginPath, "Homestead.*.yml", SearchOption.AllDirectories).Concat(Directory.EnumerateFiles(pluginPath, "Homestead.*.yaml", SearchOption.AllDirectories)).OrderBy<string, string>((string path) => path, StringComparer.OrdinalIgnoreCase))
			{
				if (!TryGetExternalLanguage(item, out string language))
				{
					continue;
				}
				if (!hashSet.Add(language))
				{
					ManualLogSource? logger = _logger;
					if (logger != null)
					{
						logger.LogWarning((object)("Duplicate external Homestead localization for language '" + language + "' skipped: " + item));
					}
					continue;
				}
				try
				{
					localization.AddYamlFile(language, File.ReadAllText(item, Encoding.UTF8));
					ManualLogSource? logger2 = _logger;
					if (logger2 != null)
					{
						logger2.LogInfo((object)("Loaded external Homestead localization '" + language + "' from " + item));
					}
				}
				catch (Exception ex)
				{
					ManualLogSource? logger3 = _logger;
					if (logger3 != null)
					{
						logger3.LogWarning((object)("Failed to load external Homestead localization '" + item + "': " + ex.Message));
					}
				}
			}
		}

		private static bool TryGetExternalLanguage(string file, out string language)
		{
			language = "";
			string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(file);
			string text = "Homestead.";
			if (!fileNameWithoutExtension.StartsWith(text, StringComparison.OrdinalIgnoreCase))
			{
				return false;
			}
			language = fileNameWithoutExtension.Substring(text.Length).Trim();
			return !string.IsNullOrWhiteSpace(language);
		}
	}
	internal static class HomesteadPlayerIdentity
	{
		public static string ResolvePlatformId(Player? player, long sender, long playerId)
		{
			if ((Object)(object)player != (Object)null)
			{
				return ResolveLocalPlatformId(playerId);
			}
			ZNet instance = ZNet.instance;
			ZNetPeer val = ((instance != null) ? instance.GetPeer(sender) : null);
			if (val != null)
			{
				return ResolvePeerPlatformId(val, playerId);
			}
			if ((Object)(object)Player.m_localPlayer != (Object)null && Player.m_localPlayer.GetPlayerID() == playerId)
			{
				return ResolveLocalPlatformId(playerId);
			}
			return FallbackPlatformId(playerId);
		}

		public static string ResolvePeerPlatformId(ZNetPeer peer, long playerId)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			if (peer == null)
			{
				return FallbackPlatformId(playerId);
			}
			ISocket socket = peer.m_socket;
			string text = ((socket != null) ? socket.GetHostName() : null) ?? "";
			if (!string.IsNullOrWhiteSpace(text))
			{
				return NormalizePlatformId(((int)ZNet.m_onlineBackend == 0) ? ("steam:" + text) : text);
			}
			return $"session:{peer.m_uid}";
		}

		public static string ResolveLocalPlatformId(long playerId)
		{
			string value = "";
			try
			{
				UserInfo localUser = UserInfo.GetLocalUser();
				value = ((localUser != null) ? ((object)(PlatformUserID)(ref localUser.UserId)).ToString() : null) ?? "";
			}
			catch
			{
			}
			value = NormalizePlatformId(value);
			if (!string.IsNullOrWhiteSpace(value))
			{
				return value;
			}
			return FallbackPlatformId(playerId);
		}

		public static string FallbackPlatformId(long playerId)
		{
			if (playerId == 0L)
			{
				return "";
			}
			return $"local:{playerId}";
		}

		public static string NormalizePlatformId(string value)
		{
			string text = (value ?? "").Trim();
			if (string.IsNullOrWhiteSpace(text))
			{
				return "";
			}
			if (text.StartsWith("Steam_", StringComparison.OrdinalIgnoreCase))
			{
				return "steam:" + text.Substring("Steam_".Length);
			}
			if (text.StartsWith("steam:", StringComparison.OrdinalIgnoreCase))
			{
				return "steam:" + text.Substring("steam:".Length).Trim();
			}
			return text;
		}

		public static bool TryGetPeerActivity(ZNetPeer peer, out string platformId, out long playerId, out string name)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			platformId = "";
			playerId = 0L;
			name = "";
			if (peer == null || !peer.IsReady())
			{
				return false;
			}
			platformId = ResolvePeerPlatformId(peer, 0L);
			playerId = TryReadPlayerId(peer.m_characterID);
			name = peer.m_playerName;
			return true;
		}

		private static long TryReadPlayerId(ZDOID characterId)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if (((ZDOID)(ref characterId)).IsNone() || ZDOMan.instance == null)
			{
				return 0L;
			}
			ZDO zDO = ZDOMan.instance.GetZDO(characterId);
			if (zDO == null)
			{
				return 0L;
			}
			return zDO.GetLong(ZDOVars.s_playerID, 0L);
		}
	}
	internal sealed class SavedZdoData
	{
		private const string Prefix = "hs-zdo-v1:";

		private const int Version = 1;

		public Dictionary<int, string> Strings { get; private set; } = new Dictionary<int, string>();


		public Dictionary<int, float> Floats { get; private set; } = new Dictionary<int, float>();


		public Dictionary<int, int> Ints { get; private set; } = new Dictionary<int, int>();


		public Dictionary<int, bool> Bools { get; private set; } = new Dictionary<int, bool>();


		public Dictionary<int, int> Hashes { get; private set; } = new Dictionary<int, int>();


		public Dictionary<int, long> Longs { get; private set; } = new Dictionary<int, long>();


		public Dictionary<int, Vector3> Vecs { get; private set; } = new Dictionary<int, Vector3>();


		public Dictionary<int, Quaternion> Quats { get; private set; } = new Dictionary<int, Quaternion>();


		public Dictionary<int, byte[]> ByteArrays { get; private set; } = new Dictionary<int, byte[]>();


		public ZDOID OriginalId { get; set; } = ZDOID.None;


		public ZDOID TargetConnectionId { get; set; } = ZDOID.None;


		public int ConnectionHash { get; set; }

		public ConnectionType ConnectionType { get; set; }

		public bool Persistent { get; private set; }

		public bool Distant { get; private set; }

		public ObjectType ObjectType { get; private set; }

		public SavedZdoData()
		{
		}//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_006f: 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)


		public SavedZdoData(ZDO zdo)
		{
			//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_006f: 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)
			Load(zdo);
		}

		public SavedZdoData(string payload)
		{
			//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_006f: 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)
			Load(payload);
		}

		public string GetBase64(Dictionary<string, string> _)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected I4, but got Unknown
			ZPackage package = new ZPackage();
			package.Write(1);
			package.Write(Persistent);
			package.Write(Distant);
			package.Write((int)ObjectType);
			WriteDictionary(package, Strings, (Action<string>)package.Write);
			WriteDictionary(package, Floats, (Action<float>)package.Write);
			WriteDictionary(package, Ints, (Action<int>)package.Write);
			WriteDictionary(package, Longs, (Action<long>)package.Write);
			WriteDictionary(package, Vecs, (Action<Vector3>)package.Write);
			WriteDictionary(package, Quats, (Action<Quaternion>)package.Write);
			WriteDictionary(package, ByteArrays, delegate(byte[] bytes)
			{
				package.Write(bytes ?? Array.Empty<byte>());
			});
			return "hs-zdo-v1:" + package.GetBase64();
		}

		public void ApplyTo(ZDO zdo)
		{
			//IL_001a: 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_0227: Unknown result type (might be due to invalid IL or missing references)
			zdo.Persistent = Persistent;
			zdo.Distant = Distant;
			zdo.Type = ObjectType;
			foreach (KeyValuePair<int, string> @string in Strings)
			{
				zdo.Set(@string.Key, @string.Value);
			}
			foreach (KeyValuePair<int, float> @float in Floats)
			{
				zdo.Set(@float.Key, @float.Value);
			}
			foreach (KeyValuePair<int, int> @int in Ints)
			{
				zdo.Set(@int.Key, @int.Value, false);
			}
			foreach (KeyValuePair<int, bool> @bool in Bools)
			{
				zdo.Set(@bool.Key, @bool.Value);
			}
			foreach (KeyValuePair<int, int> hash in Hashes)
			{
				zdo.Set(hash.Key, hash.Value, false);
			}
			foreach (KeyValuePair<int, long> @long in Longs)
			{
				zdo.Set(@long.Key, @long.Value);
			}
			foreach (KeyValuePair<int, Vector3> vec in Vecs)
			{
				zdo.Set(vec.Key, vec.Value);
			}
			foreach (KeyValuePair<int, Quaternion> quat in Quats)
			{
				zdo.Set(quat.Key, quat.Value);
			}
			foreach (KeyValuePair<int, byte[]> byteArray in ByteArrays)
			{
				zdo.Set(byteArray.Key, byteArray.Value.ToArray());
			}
		}

		private void Load(ZDO zdo)
		{
			//IL_0002: 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_0032: 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_00da: 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_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: 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)
			OriginalId = zdo.m_uid;
			Persistent = zdo.Persistent;
			Distant = zdo.Distant;
			ObjectType = zdo.Type;
			Strings = ZDOExtraData.GetStrings(zdo.m_uid).ToDictionary((KeyValuePair<int, string> item) => item.Key, (KeyValuePair<int, string> item) => item.Value);
			Floats = ZDOExtraData.GetFloats(zdo.m_uid).ToDictionary((KeyValuePair<int, float> item) => item.Key, (KeyValuePair<int, float> item) => item.Value);
			Ints = ZDOExtraData.GetInts(zdo.m_uid).ToDictionary((KeyValuePair<int, int> item) => item.Key, (KeyValuePair<int, int> item) => item.Value);
			Longs = ZDOExtraData.GetLongs(zdo.m_uid).ToDictionary((KeyValuePair<int, long> item) => item.Key, (KeyValuePair<int, long> item) => item.Value);
			Vecs = ZDOExtraData.GetVec3s(zdo.m_uid).ToDictionary((KeyValuePair<int, Vector3> item) => item.Key, (KeyValuePair<int, Vector3> item) => item.Value);
			Quats = ZDOExtraData.GetQuaternions(zdo.m_uid).ToDictionary((KeyValuePair<int, Quaternion> item) => item.Key, (KeyValuePair<int, Quaternion> item) => item.Value);
			ByteArrays = ZDOExtraData.GetByteArrays(zdo.m_uid).ToDictionary((KeyValuePair<int, byte[]> item) => item.Key, (KeyValuePair<int, byte[]> item) => item.Value.ToArray());
		}

		private void Load(string payload)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			if (!payload.StartsWith("hs-zdo-v1:", StringComparison.Ordinal))
			{
				throw new InvalidDataException("Unsupported Homestead ZDO data format. Re-save this blueprint with the current Homestead version.");
			}
			ZPackage package = new ZPackage(payload.Substring("hs-zdo-v1:".Length));
			int num = package.ReadInt();
			if (num != 1)
			{
				throw new InvalidDataException($"Unsupported Homestead ZDO data version {num}.");
			}
			Persistent = package.ReadBool();
			Distant = package.ReadBool();
			ObjectType = (ObjectType)(byte)package.ReadInt();
			Strings = ReadDictionary(package, () => package.ReadString());
			Floats = ReadDictionary(package, () => package.ReadSingle());
			Ints = ReadDictionary(package, () => package.ReadInt());
			Longs = ReadDictionary(package, () => package.ReadLong());
			Vecs = ReadDictionary(package, () => package.ReadVector3());
			Quats = ReadDictionary(package, () => package.ReadQuaternion());
			ByteArrays = ReadDictionary(package, () => package.ReadByteArray().ToArray());
		}

		private static void WriteDictionary<T>(ZPackage package, Dictionary<int, T> values, Action<T> writeValue)
		{
			package.Write(values.Count);
			foreach (KeyValuePair<int, T> item in values.OrderBy<KeyValuePair<int, T>, int>((KeyValuePair<int, T> item) => item.Key))
			{
				package.Write(item.Key);
				writeValue(item.Value);
			}
		}

		private static Dictionary<int, T> ReadDictionary<T>(ZPackage package, Func<T> readValue)
		{
			int num = package.ReadInt();
			Dictionary<int, T> dictionary = new Dictionary<int, T>(num);
			for (int i = 0; i < num; i++)
			{
				int key = package.ReadInt();
				dictionary[key] = readValue();
			}
			return dictionary;
		}
	}
	internal static class SavedZdoHelper
	{
		public static ZDO? Init(GameObject prefab, Vector3 position, Quaternion rotation, Vector3? scale, SavedZdoData data, Dictionary<string, string> _)
		{
			//IL_0022: 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_0062: 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)
			if (ZDOMan.instance == null || !Object.op_Implicit((Object)(object)prefab))
			{
				return null;
			}
			int stableHashCode = StringExtensionMethods.GetStableHashCode(((Object)prefab).name);
			ZDO val = ZDOMan.instance.CreateNewZDO(position, stableHashCode);
			val.SetPrefab(stableHashCode);
			val.SetRotation(rotation);
			ZNetView component = prefab.GetComponent<ZNetView>();
			if ((Object)(object)component != (Object)null)
			{
				val.Persistent = component.m_persistent;
				val.Distant = component.m_distant;
				val.Type = component.m_type;
			}
			data.ApplyTo(val);
			if (scale.HasValue)
			{
				val.Set(ZDOVars.s_scaleHash, scale.Value);
			}
			return val;
		}

		public static void Destroy(ZDO zdo)
		{
			//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_0012: 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_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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_008d: 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)
			if (zdo == null || ZDOMan.instance == null)
			{
				return;
			}
			ZDOID uid = zdo.m_uid;
			if (!CanDestroyZdo(uid))
			{
				return;
			}
			zdo.SetOwner(ZDOMan.GetSessionID());
			ZDOID connectionZDOID = zdo.GetConnectionZDOID((ConnectionType)3);
			if (connectionZDOID != ZDOID.None && ZDOMan.instance.m_objectsByID.TryGetValue(connectionZDOID, out var value) && value != zdo)
			{
				Destroy(value);
			}
			ZNetScene instance = ZNetScene.instance;
			if ((Object)(object)instance != (Object)null)
			{
				ZNetView val = instance.FindInstance(zdo);
				if ((Object)(object)val != (Object)null)
				{
					instance.Destroy(((Component)val).gameObject);
				}
			}
			ZDO zDO = ZDOMan.instance.GetZDO(uid);
			if (zDO != null && zDO.IsValid())
			{
				zDO.SetOwner(ZDOMan.GetSessionID());
				ZDOMan.instance.DestroyZDO(zDO);
				ZDOMan.instance.HandleDestroyedZDO(uid);
			}
		}

		public static void FlushDestroyed()
		{
			ZDOMan instance = ZDOMan.instance;
			if (instance != null)
			{
				instance.SendDestroyed();
			}
		}

		private static bool CanDestroyZdo(ZDOID id)
		{
			//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_001f: 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)
			if ((Object)(object)Player.m_localPlayer != (Object)null && ((Character)Player.m_localPlayer).GetZDOID() == id)
			{
				return false;
			}
			if (!((Object)(object)ZNet.instance == (Object)null))
			{
				return !ZNet.instance.m_peers.Any((ZNetPeer peer) => peer != null && peer.m_characterID == id);
			}
			return true;
		}
	}
	internal static class HomesteadTerrainSupport
	{
		private readonly struct TerrainSupportCell
		{
			public int X { get; }

			public int Z { get; }

			public float Height { get; }

			public TerrainSupportCell(int x, int z, float height)
			{
				X = x;
				Z = z;
				Height = height;
			}
		}

		private sealed class TerrainSupportCellIndex
		{
			private readonly Dictionary<long, List<TerrainSupportCell>> _cellsByBucket = new Dictionary<long, List<TerrainSupportCell>>();

			private readonly float _bucketSize;

			private readonly int _searchRadius;

			public TerrainSupportCellIndex(IEnumerable<TerrainSupportCell> cells, float featherWidth)
			{
				_bucketSize = Mathf.Max(1f, featherWidth);
				_searchRadius = Mathf.Max(0, Mathf.CeilToInt(featherWidth / _bucketSize));
				foreach (TerrainSupportCell cell in cells)
				{
					long key = PackCell(ToBucket(cell.X), ToBucket(cell.Z));
					if (!_cellsByBucket.TryGetValue(key, out List<TerrainSupportCell> value))
					{
						value = new List<TerrainSupportCell>();
						_cellsByBucket[key] = value;
					}
					value.Add(cell);
				}
			}

			public bool TryGetNearest(Vector3 node, float maxDistanceSqr, out TerrainSupportCell nearest, out float bestDistanceSqr)
			{
				//IL_001f: 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_007e: 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)
				nearest = default(TerrainSupportCell);
				bestDistanceSqr = float.PositiveInfinity;
				if (_cellsByBucket.Count == 0)
				{
					return false;
				}
				int num = ToBucket(node.x);
				int num2 = ToBucket(node.z);
				for (int i = num2 - _searchRadius; i <= num2 + _searchRadius; i++)
				{
					for (int j = num - _searchRadius; j <= num + _searchRadius; j++)
					{
						if (!_cellsByBucket.TryGetValue(PackCell(j, i), out List<TerrainSupportCell> value))
						{
							continue;
						}
						foreach (TerrainSupportCell item in value)
						{
							float num3 = node.x - (float)item.X;
							float num4 = node.z - (float)item.Z;
							float num5 = num3 * num3 + num4 * num4;
							if (!(num5 >= bestDistanceSqr) && !(num5 > maxDistanceSqr))
							{
								bestDistanceSqr = num5;
								nearest = item;
							}
						}
					}
				}
				return !float.IsPositiveInfinity(bestDistanceSqr);
			}

			private int ToBucket(float value)
			{
				return Mathf.FloorToInt(value / _bucketSize);
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass7_0
		{
			public bool zoneChanged;

			internal void <ApplyWorldSupportContactsAsync>b__3(bool result)
			{
				zoneChanged = result;
			}
		}

		[CompilerGenerated]
		private sealed class <ApplySupportCellsToHeightmapAsync>d__12 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Heightmap heightmap;

			public List<TerrainSupportCell> supportCells;

			public Dictionary<long, float> supportHeights;

			public Action<bool> onComplete;

			private int <width>5__2;

			private float[] <worldHeights>5__3;

			private Color[] <paints>5__4;

			private float <featherWidth>5__5;

			private TerrainSupportCellIndex <supportIndex>5__6;

			private bool <changed>5__7;

			private int <processed>5__8;

			private int <z>5__9;

			private int <x>5__10;

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

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

			[DebuggerHidden]
			public <ApplySupportCellsToHeightmapAsync>d__12(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<worldHeights>5__3 = null;
				<paints>5__4 = null;
				<supportIndex>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//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_00ea: 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_0277: 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_0128: 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_013e: 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)
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					goto IL_01d7;
				}
				<>1__state = -1;
				<width>5__2 = heightmap.m_width + 1;
				<worldHeights>5__3 = new float[<width>5__2 * <width>5__2];
				<paints>5__4 = (Color[])(object)new Color[<width>5__2 * <width>5__2];
				<featherWidth>5__5 = BlueprintConfig.TerrainSupportFeatherWidth;
				<supportIndex>5__6 = new TerrainSupportCellIndex(supportCells, <featherWidth>5__5);
				<changed>5__7 = false;
				<processed>5__8 = 0;
				<z>5__9 = 0;
				goto IL_020c;
				IL_020c:
				if (<z>5__9 < <width>5__2)
				{
					<x>5__10 = 0;
					goto IL_01e9;
				}
				if (!<changed>5__7)
				{
					onComplete(obj: false);
					return false;
				}
				PersistSupportFillBaseLayer(heightmap.GetAndCreateTerrainCompiler(), <width>5__2, <worldHeights>5__3, <paints>5__4);
				heightmap.Poke(false);
				ClutterSystem instance = ClutterSystem.instance;
				if (instance != null)
				{
					instance.ResetGrass(((Component)heightmap).transform.position, 48f);
				}
				onComplete(obj: true);
				return false;
				IL_01d7:
				<x>5__10++;
				goto IL_01e9;
				IL_01e9:
				if (<x>5__10 < <width>5__2)
				{
					int num2 = <z>5__9 * <width>5__2 + <x>5__10;
					Vector3 val = VertexToWorld(heightmap, <x>5__10, <z>5__9);
					float worldHeight = GetWorldHeight(heightmap, <x>5__10, <z>5__9);
					float height;
					float num3 = (TryGetTerrainBaseHeight(val.x, val.z, out height) ? height : worldHeight);
					float num4 = num3;
					<paints>5__4[num2] = GetPaint(heightmap, <x>5__10, <z>5__9);
					float height2;
					if (supportHeights.TryGetValue(PackCell(Mathf.RoundToInt(val.x), Mathf.RoundToInt(val.z)), out var value))
					{
						num4 = value;
					}
					else if (TryGetFeatheredSupportHeight(val, num3, <supportIndex>5__6, <featherWidth>5__5, out height2))
					{
						num4 = height2;
					}
					<worldHeights>5__3[num2] = num4;
					if (Mathf.Abs(worldHeight - num4) > 0.01f)
					{
						<changed>5__7 = true;
					}
					<processed>5__8++;
					if (<processed>5__8 >= 1024)
					{
						<processed>5__8 = 0;
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					goto IL_01d7;
				}
				<z>5__9++;
				goto IL_020c;
			}

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

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

		[CompilerGenerated]
		private sealed class <ApplyWorldSupportContactsAsync>d__7 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public IEnumerable<Vector3> supportContacts;

			public Action<bool> onComplete;

			private <>c__DisplayClass7_0 <>8__1;

			private List<TerrainSupportCell> <supportCells>5__2;

			private Dictionary<long, float> <supportHeights>5__3;

			private bool <changed>5__4;

			private List<Vector2i>.Enumerator <>7__wrap4;

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

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

			[DebuggerHidden]
			public <ApplyWorldSupportContactsAsync>d__7(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || (uint)(num - 1) <= 1u)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>8__1 = null;
				<supportCells>5__2 = null;
				<supportHeights>5__3 = null;
				<>7__wrap4 = default(List<Vector2i>.Enumerator);
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0102: Unknown result type (might be due to invalid IL or missing references)
				bool result2;
				try
				{
					switch (<>1__state)
					{
					default:
						result2 = false;
						goto end_IL_0000;
					case 0:
						<>1__state = -1;
						<supportCells>5__2 = BuildSupportCells(supportContacts);
						if (<supportCells>5__2.Count != 0)
						{
							<supportHeights>5__3 = <supportCells>5__2.ToDictionary((TerrainSupportCell cell) => PackCell(cell.X, cell.Z), (TerrainSupportCell cell) => cell.Height);
							List<Vector2i> list = <supportCells>5__2.Select((TerrainSupportCell cell) => ZoneSystem.GetZone(new Vector3((float)cell.X, 0f, (float)cell.Z))).Distinct().ToList();
							<changed>5__4 = false;
							<>7__wrap4 = list.GetEnumerator();
							<>1__state = -3;
							break;
						}
						onComplete(obj: false);
						result2 = false;
						goto end_IL_0000;
					case 1:
						<>1__state = -3;
						<changed>5__4 |= <>8__1.zoneChanged;
						<>2__current = null;
						<>1__state = 2;
						result2 = true;
						goto end_IL_0000;
					case 2:
						<>1__state = -3;
						<>8__1 = null;
						break;
					}
					if (<>7__wrap4.MoveNext())
					{
						Vector2i current = <>7__wrap4.Current;
						<>8__1 = new <>c__DisplayClass7_0();
						if (!TryGetHeightmap(current, out Heightmap heightmap))
						{
							onComplete(obj: false);
							result2 = false;
							<>m__Finally1();
						}
						else
						{
							<>8__1.zoneChanged = false;
							<>2__current = ApplySupportCellsToHeightmapAsync(heightmap, <supportHeights>5__3, <supportCells>5__2, delegate(bool result)
							{
								<>8__1.zoneChanged = result;
							});
							<>1__state = 1;
							result2 = true;
						}
					}
					else
					{
						<>m__Finally1();
						<>7__wrap4 = default(List<Vector2i>.Enumerator);
						onComplete(<changed>5__4);
						result2 = false;
					}
					end_IL_0000:;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
				return result2;
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>7__wrap4).Dispose();
			}

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

		[CompilerGenerated]
		private sealed class <GetBoundsCorners>d__37 : IEnumerable<Vector3>, IEnumerable, IEnumerator<Vector3>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private Vector3 <>2__current;

			private int <>l__initialThreadId;

			private Bounds bounds;

			public Bounds <>3__bounds;

			private Vector3 <min>5__2;

			private Vector3 <max>5__3;

			Vector3 IEnumerator<Vector3>.Current
			{
				[DebuggerHidden]
				get
				{
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					return <>2__current;
				}
			}

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

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

			private bool MoveNext()
			{
				//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_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_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_00ba: 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_00f6: 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_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_016e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0173: Unknown result type (might be due to invalid IL or missing references)
				//IL_01aa: 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_01e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0222: Unknown result type (might be due to invalid IL or missing references)
				//IL_0227: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<min>5__2 = ((Bounds)(ref bounds)).min;
					<max>5__3 = ((Bounds)(ref bounds)).max;
					<>2__current = new Vector3(<min>5__2.x, <min>5__2.y, <min>5__2.z);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = new Vector3(<min>5__2.x, <min>5__2.y, <max>5__3.z);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = new Vector3(<min>5__2.x, <max>5__3.y, <min>5__2.z);
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					<>2__current = new Vector3(<min>5__2.x, <max>5__3.y, <max>5__3.z);
					<>1__state = 4;
					return true;
				case 4:
					<>1__state = -1;
					<>2__current = new Vector3(<max>5__3.x, <min>5__2.y, <min>5__2.z);
					<>1__state = 5;
					return true;
				case 5:
					<>1__state = -1;
					<>2__current = new Vector3(<max>5__3.x, <min>5__2.y, <max>5__3.z);
					<>1__state = 6;
					return true;
				case 6:
					<>1__state = -1;
					<>2__current = new Vector3(<max>5__3.x, <max>5__3.y, <min>5__2.z);
					<>1__state = 7;
					return true;
				case 7:
					<>1__state = -1;
					<>2__current = new Vector3(<max>5__3.x, <max>5__3.y, <max>5__3.z);
					<>1__state = 8;
					return true;
				case 8:
					<>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<Vector3> IEnumerable<Vector3>.GetEnumerator()
			{
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				<GetBoundsCorners>d__37 <GetBoundsCorners>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<GetBoundsCorners>d__ = this;
				}
				else
				{
					<GetBoundsCorners>d__ = new <GetBoundsCorners>d__37(0);
				}
				<GetBoundsCorners>d__.bounds = <>3__bounds;
				return <GetBoundsCorners>d__;
			}

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

		private const float SearchRadius = 48f;

		private const float SupportFillClearance = 0.05f;

		private const int TerrainApplyNodeBatchSize = 1024;

		private static readonly int SupportFillBaseLayerHash = StringExtensionMethods.GetStableHashCode("sighsorry.Homestead.terrain_base_v1");

		public static bool TryGetWearNTearBounds(GameObject prefab, Vector3 position, Quaternion rotation, Vector3 scale, out Bounds bounds)
		{
			//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_0003: Unknown result type (might be due to invalid IL or missing references)
			return TryGetWearNTearWorldBounds(prefab, position, rotation, scale, out bounds);
		}

		public static bool TryGetTerrainHeight(float x, float z, out float height)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return Heightmap.GetHeight(new Vector3(x, 0f, z), ref height);
		}

		public static bool ApplyWorldSupportContacts(IEnumerable<Vector3> supportContacts)
		{
			//IL_0091: 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_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			List<TerrainSupportCell> list = BuildSupportCells(supportContacts);
			if (list.Count == 0)
			{
				return false;
			}
			Dictionary<long, float> supportHeights = list.ToDictionary((TerrainSupportCell cell) => PackCell(cell.X, cell.Z), (TerrainSupportCell cell) => cell.Height);
			List<Vector2i> list2 = list.Select((TerrainSupportCell cell) => ZoneSystem.GetZone(new Vector3((float)cell.X, 0f, (float)cell.Z))).Distinct().ToList();
			bool flag = false;
			foreach (Vector2i item in list2)
			{
				if (!TryGetHeightmap(item, out Heightmap heightmap))
				{
					throw new InvalidOperationException($"Target terrain zone ({item.x},{item.y}) is not loaded for blueprint support placement.");
				}
				flag |= ApplySupportCellsToHeightmap(heightmap, supportHeights, list);
			}
			return flag;
		}

		[IteratorStateMachine(typeof(<ApplyWorldSupportContactsAsync>d__7))]
		public static IEnumerator ApplyWorldSupportContactsAsync(IEnumerable<Vector3> supportContacts, Action<bool> onComplete)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ApplyWorldSupportContactsAsync>d__7(0)
			{
				supportContacts = supportContacts,
				onComplete = onComplete
			};
		}

		public static void ApplyBaseLayer(Heightmap heightmap)
		{
			//IL_0006: 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_00d0: Unknown result type (might be due to invalid IL or missing references)
			TerrainComp val = TerrainComp.FindTerrainCompiler(((Component)heightmap).transform.position);
			if (!IsCompilerReady(val))
			{
				return;
			}
			byte[] byteArray = val.m_nview.GetZDO().GetByteArray(SupportFillBaseLayerHash, (byte[])null);
			if (byteArray == null || byteArray.Length == 0 || !TryDeserializeBaseLayer(byteArray, heightmap, out int width, out float[] worldHeights, out Color[] paints) || width != heightmap.m_width + 1 || worldHeights.Length != heightmap.m_heights.Count || (paints.Length != 0 && paints.Length != worldHeights.Length))
			{
				return;
			}
			float y = ((Component)heightmap).transform.position.y;
			for (int i = 0; i < worldHeights.Length; i++)
			{
				heightmap.m_heights[i] = worldHeights[i] - y;
			}
			if (paints.Length != worldHeights.Length)
			{
				return;
			}
			for (int j = 0; j < width; j++)
			{
				for (int k = 0; k < width; k++)
				{
					heightmap.m_paintMask.SetPixel(k, j, paints[j * width + k]);
				}
			}
		}

		internal static void ResetSupportFillBaseLayer(IEnumerable? heightNodes, IEnumerable? paintNodes, Vector3 position, float radius)
		{
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: 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_0161: 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_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: 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_0180: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<TerrainComp, HashSet<int>> dictionary = CollectTerrainNodeIndices(heightNodes);
			Dictionary<TerrainComp, HashSet<int>> dictionary2 = CollectTerrainNodeIndices(paintNodes);
			if (dictionary.Count == 0 && dictionary2.Count == 0)
			{
				return;
			}
			HashSet<TerrainComp> hashSet = dictionary.Keys.Concat(dictionary2.Keys).ToHashSet();
			int num = 0;
			foreach (TerrainComp item in hashSet)
			{
				if (!TryLoadSupportFillBaseLayer(item, out int width, out float[] worldHeights, out Color[] paints))
				{
					continue;
				}
				bool flag = false;
				if (dictionary.TryGetValue(item, out var value))
				{
					foreach (int item2 in value)
					{
						if (IsValidPayloadIndex(item2, width, worldHeights.Length))
						{
							IndexToXZ(item2, width, out var x, out var z);
							Vector3 val = VertexToWorld(item.m_hmap, x, z);
							if (TryGetTerrainBaseHeight(val.x, val.z, out var height) && Mathf.Abs(worldHeights[item2] - height) > 0.01f)
							{
								worldHeights[item2] = height;
								flag = true;
							}
						}
					}
				}
				bool num2 = paints.Length == width * width;
				Color[] array = (num2 ? TryGetBasePaints(item.m_hmap, width) : null);
				if (num2 && array != null && dictionary2.TryGetValue(item, out var value2))
				{
					foreach (int item3 in value2)
					{
						if (IsValidPayloadIndex(item3, width, paints.Length) && item3 < array.Length)
						{
							Color val2 = array[item3];
							if (!Approximately(paints[item3], val2))
							{
								paints[item3] = val2;
								flag = true;
							}
						}
					}
				}
				if (flag)
				{
					if (IsSupportFillBaseLayerNative(item.m_hmap, width, worldHeights, paints, array))
					{
						item.m_nview.GetZDO().Set(SupportFillBaseLayerHash, Array.Empty<byte>());
					}
					else
					{
						item.m_nview.GetZDO().Set(SupportFillBaseLayerHash, SerializeBaseLayer(item.m_hmap, width, worldHeights, paints));
					}
					PersistCompiler(item);
					num++;
				}
			}
			if (num > 0)
			{
				ClutterSystem instance = ClutterSystem.instance;
				if (instance != null)
				{
					instance.ResetGrass(position, radius);
				}
			}
		}

		private static List<TerrainSupportCell> BuildSupportCells(IEnumerable<Vector3> supportContacts)
		{
			return (from contact in supportContacts
				select new TerrainSupportCell(Mathf.RoundToInt(contact.x), Mathf.RoundToInt(contact.z), contact.y - 0.05f) into cell
				group cell by PackCell(cell.X, cell.Z) into @group
				select @group.OrderBy((TerrainSupportCell cell) => cell.Height).First()).ToList();
		}

		private static bool ApplySupportCellsToHeightmap(Heightmap heightmap, Dictionary<long, float> supportHeights, List<TerrainSupportCell> supportCells)
		{
			//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_005e: 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_0136: 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_0094: 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_00c0: Unknown result type (might be due to invalid IL or missing references)
			int num = heightmap.m_width + 1;
			float[] array = new float[num * num];
			Color[] array2 = (Color[])(object)new Color[num * num];
			float terrainSupportFeatherWidth = BlueprintConfig.TerrainSupportFeatherWidth;
			TerrainSupportCellIndex supportIndex = new TerrainSupportCellIndex(supportCells, terrainSupportFeatherWidth);
			bool flag = false;
			for (int i = 0; i < num; i++)
			{
				for (int j = 0; j < num; j++)
				{
					int num2 = i * num + j;
					Vector3 val = VertexToWorld(heightmap, j, i);
					float worldHeight = GetWorldHeight(heightmap, j, i);
					float height;
					float num3 = (TryGetTerrainBaseHeight(val.x, val.z, out height) ? height : worldHeight);
					float num4 = num3;
					array2[num2] = GetPaint(heightmap, j, i);
					float height2;
					if (supportHeights.TryGetValue(PackCell(Mathf.RoundToInt(val.x), Mathf.RoundToInt(val.z)), out var value))
					{
						num4 = value;
					}
					else if (TryGetFeatheredSupportHeight(val, num3, supportIndex, terrainSupportFeatherWidth, out height2))
					{
						num4 = height2;
					}
					array[num2] = num4;
					if (Mathf.Abs(worldHeight - num4) > 0.01f)
					{
						flag = true;
					}
				}
			}
			if (!flag)
			{
				return false;
			}
			PersistSupportFillBaseLayer(heightmap.GetAndCreateTerrainCompiler(), num, array, array2);
			heightmap.Poke(false);
			ClutterSystem instance = ClutterSystem.instance;
			if (instance != null)
			{
				instance.ResetGrass(((Component)heightmap).transform.position, 48f);
			}
			return true;
		}

		[IteratorStateMachine(typeof(<ApplySupportCellsToHeightmapAsync>d__12))]
		private static IEnumerator ApplySupportCellsToHeightmapAsync(Heightmap heightmap, Dictionary<long, float> supportHeights, List<TerrainSupportCell> supportCells, Action<bool> onComplete)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ApplySupportCellsToHeightmapAsync>d__12(0)
			{
				heightmap = heightmap,
				supportHeights = supportHeights,
				supportCells = supportCells,
				onComplete = onComplete
			};
		}

		private static bool TryGetFeatheredSupportHeight(Vector3 node, float baseHeight, TerrainSupportCellIndex supportIndex, float featherWidth, out float height)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			height = baseHeight;
			if (featherWidth <= 0f)
			{
				return false;
			}
			float maxDistanceSqr = featherWidth * featherWidth;
			if (!supportIndex.TryGetNearest(node, maxDistanceSqr, out var nearest, out var bestDistanceSqr))
			{
				return false;
			}
			float num = Mathf.Sqrt(bestDistanceSqr);
			float num2 = 1f - Mathf.Clamp01(num / featherWidth);
			num2 = num2 * num2 * (3f - 2f * num2);
			height = Mathf.Lerp(baseHeight, nearest.Height, num2);
			return true;
		}

		private static bool TryLoadSupportFillBaseLayer(TerrainComp compiler, out int width, out float[] worldHeights, out Color[] paints)
		{
			width = 0;
			worldHeights = Array.Empty<float>();
			paints = Array.Empty<Color>();
			if (!IsCompilerReady(compiler))
			{
				return false;
			}
			byte[] byteArray = compiler.m_nview.GetZDO().GetByteArray(SupportFillBaseLayerHash, (byte[])null);
			if (byteArray != null && byteArray.Length != 0 && TryDeserializeBaseLayer(byteArray, compiler.m_hmap, out width, out worldHeights, out paints) && width == compiler.m_hmap.m_width + 1 && worldHeights.Length == width * width)
			{
				if (paints.Length != 0)
				{
					return paints.Length == worldHeights.Length;
				}
				return true;
			}
			return false;
		}

		private static Dictionary<TerrainComp, HashSet<int>> CollectTerrainNodeIndices(IEnumerable? nodes)
		{
			Dictionary<TerrainComp, HashSet<int>> dictionary = new Dictionary<TerrainComp, HashSet<int>>();
			if (nodes == null)
			{
				return dictionary;
			}
			foreach (object node in nodes)
			{
				if (TryReadTerrainNode(node, out TerrainComp compiler, out int index))
				{
					if (!dictionary.TryGetValue(compiler, out var value))
					{
						value = (dictionary[compiler] = new HashSet<int>());
					}
					value.Add(index);
				}
			}
			return dictionary;
		}

		private static bool TryReadTerrainNode(object? node, out TerrainComp compiler, out int index)
		{
			compiler = null;
			index = -1;
			if (node == null)
			{
				return false;
			}
			Type type = node.GetType();
			FieldInfo fieldInfo = AccessTools.Field(type, "Compiler");
			FieldInfo fieldInfo2 = AccessTools.Field(type, "Index");
			object? obj = fieldInfo?.GetValue(node);
			TerrainComp val = (TerrainComp)((obj is TerrainComp) ? obj : null);
			object obj2 = fieldInfo2?.GetValue(node);
			if ((Object)(object)val == (Object)null || !(obj2 is int num))
			{
				return false;
			}
			compiler = val;
			index = num;
			return true;
		}

		private static byte[] SerializeBaseLayer(Heightmap heightmap, int width, float[] worldHeights, Color[] paints)
		{
			Color[] paints2 = (ShouldSerializePaints(heightmap, width, paints) ? paints : Array.Empty<Color>());
			return SerializeSparseBaseLayer(heightmap, width, worldHeights, paints2);
		}

		private static byte[] SerializeSparseBaseLayer(Heightmap heightmap, int width, float[] worldHeights, Color[] paints)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Expected O, but got Unknown
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: 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_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			List<int> list = new List<int>();
			List<float> list2 = new List<float>();
			for (int i = 0; i < worldHeights.Length; i++)
			{
				IndexToXZ(i, width, out var x, out var z);
				Vector3 val = VertexToWorld(heightmap, x, z);
				float height;
				float num = (TryGetTerrainBaseHeight(val.x, val.z, out height) ? height : GetWorldHeight(heightmap, x, z));
				if (!(Mathf.Abs(worldHeights[i] - num) <= 0.01f))
				{
					list.Add(i);
					list2.Add(worldHeights[i]);
				}
			}
			List<int> list3 = new List<int>();
			List<Color> list4 = new List<Color>();
			if (paints.Length == worldHeights.Length)
			{
				Color[] array = TryGetBasePaints(heightmap, width);
				for (int j = 0; j < paints.Length; j++)
				{
					Color b = ((array != null && array.Length == paints.Length) ? array[j] : GetPaint(heightmap, j % width, j / width));
					if (!Approximately(paints[j], b))
					{
						list3.Add(j);
						list4.Add(paints[j]);
					}
				}
			}
			ZPackage val2 = new ZPackage();
			val2.Write(3);
			val2.Write(width);
			val2.Write(worldHeights.Length);
			val2.Write(list.Count);
			for (int k = 0; k < list.Count; k++)
			{
				val2.Write(list[k]);
				val2.Write(list2[k]);
			}
			val2.Write(list3.Count);
			for (int l = 0; l < list3.Count; l++)
			{
				val2.Write(list3[l]);
				WriteColor(val2, list4[l]);
			}
			return Utils.Compress(val2.GetArray());
		}

		private static bool TryDeserializeBaseLayer(byte[] payload, Heightmap heightmap, out int width, out float[] worldHeights, out Color[] paints)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			width = 0;
			worldHeights = Array.Empty<float>();
			paints = Array.Empty<Color>();
			try
			{
				ZPackage val = new ZPackage(Utils.Decompress(payload));
				if (val.ReadInt() != 3)
				{
					return false;
				}
				width = val.ReadInt();
				int heightCount = val.ReadInt();
				return TryDeserializeSparseBaseLayer(val, heightmap, width, heightCount, out worldHeights, out paints);
			}
			catch
			{
				return false;
			}
		}

		private static bool TryDeserializeSparseBaseLayer(ZPackage package, Heightmap heightmap, int width, int heightCount, out float[] worldHeights, out Color[] paints)
		{
			//IL_0044: 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_004f: 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_00fd: 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_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			worldHeights = new float[heightCount];
			paints = Array.Empty<Color>();
			if ((Object)(object)heightmap == (Object)null || width <= 0 || width != heightmap.m_width + 1 || heightCount != width * width)
			{
				return false;
			}
			for (int i = 0; i < worldHeights.Length; i++)
			{
				IndexToXZ(i, width, out var x, out var z);
				Vector3 val = VertexToWorld(heightmap, x, z);
				worldHeights[i] = (TryGetTerrainBaseHeight(val.x, val.z, out var height) ? height : GetWorldHeight(heightmap, x, z));
			}
			int num = package.ReadInt();
			for (int j = 0; j < num; j++)
			{
				int num2 = package.ReadInt();
				float num3 = package.ReadSingle();
				if (num2 < 0 || num2 >= worldHeights.Length)
				{
					return false;
				}
				worldHeights[num2] = num3;
			}
			int num4 = package.ReadInt();
			if (num4 <= 0)
			{
				return true;
			}
			paints = TryGetBasePaints(heightmap, width) ?? BuildCurrentPaintLayer(heightmap, width);
			if (paints.Length != worldHeights.Length)
			{
				return false;
			}
			for (int k = 0; k < num4; k++)
			{
				int num5 = package.ReadInt();
				Color val2 = ReadColor(package);
				if (num5 < 0 || num5 >= paints.Length)
				{
					return false;
				}
				paints[num5] = val2;
			}
			return true;
		}

		private static void PersistSupportFillBaseLayer(TerrainComp compiler, int width, float[] worldHeights, Color[] paints)
		{
			if (!IsCompilerReady(compiler))
			{
				throw new InvalidOperationException("Target terrain compiler is not network ready.");
			}
			if (!compiler.m_nview.IsOwner())
			{
				compiler.m_nview.ClaimOwnership();
			}
			Array.Clear(compiler.m_modifiedHeight, 0, compiler.m_modifiedHeight.Length);
			Array.Clear(compiler.m_levelDelta, 0, compiler.m_levelDelta.Length);
			Array.Clear(compiler.m_smoothDelta, 0, compiler.m_smoothDelta.Length);
			Array.Clear(compiler.m_modifiedPaint, 0, compiler.m_modifiedPaint.Length);
			Array.Clear(compiler.m_paintMask, 0, compiler.m_paintMask.Length);
			compiler.m_nview.GetZDO().Set(SupportFillBaseLayerHash, SerializeBaseLayer(compiler.m_hmap, width, worldHeights, paints));
			PersistCompiler(compiler);
		}

		private static void PersistCompiler(TerrainComp compiler)
		{
			//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)
			if ((Object)(object)compiler.m_nview != (Object)null && compiler.m_nview.IsValid() && !compiler.m_nview.IsOwner())
			{
				compiler.m_nview.ClaimOwnership();
			}
			compiler.m_operations++;
			compiler.m_lastOpPoint = Vector3.zero;
			compiler.m_lastOpRadius = 0f;
			compiler.Save();
			compiler.m_hmap.Poke(false);
		}

		private static bool ShouldSerializePaints(Heightmap heightmap, int width, Color[] paints)
		{
			//IL_0025: 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)
			if (paints.Length != width * width)
			{
				return false;
			}
			Color[] array = TryGetBasePaints(heightmap, width);
			if (array == null || array.Length != paints.Length)
			{
				return true;
			}
			for (int i = 0; i < paints.Length; i++)
			{
				if (!Approximately(paints[i], array[i]))
				{
					return true;
				}
			}
			return false;
		}

		private static Color[] BuildCurrentPaintLayer(Heightmap heightmap, int width)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			Color[] array = (Color[])(object)new Color[width * width];
			for (int i = 0; i < width; i++)
			{
				for (int j = 0; j < width; j++)
				{
					array[i * width + j] = GetPaint(heightmap, j, i);
				}
			}
			return array;
		}

		private static Color[]? TryGetBasePaints(Heightmap heightmap, int width)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (HeightmapBuilder.instance == null || WorldGenerator.instance == null)
			{
				return null;
			}
			try
			{
				HMBuildData val = HeightmapBuilder.instance.RequestTerrainSync(((Component)heightmap).transform.position, heightmap.m_width, heightmap.m_scale, heightmap.IsDistantLod, WorldGenerator.instance);
				return (val.m_baseMask != null && val.m_baseMask.Length == width * width) ? val.m_baseMask : null;
			}
			catch
			{
				return null;
			}
		}

		private static bool IsSupportFillBaseLayerNative(Heightmap heightmap, int width, float[] worldHeights, Color[] paints, Color[]? basePaints)
		{
			//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_0034: 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_0062: 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)
			bool flag = paints.Length == width * width;
			if (flag && (basePaints == null || basePaints.Length != paints.Length))
			{
				return false;
			}
			for (int i = 0; i < worldHeights.Length; i++)
			{
				IndexToXZ(i, width, out var x, out var z);
				Vector3 val = VertexToWorld(heightmap, x, z);
				if (!TryGetTerrainBaseHeight(val.x, val.z, out var height) || Mathf.Abs(worldHeights[i] - height) > 0.01f || (flag && !Approximately(paints[i], basePaints[i])))
				{
					return false;
				}
			}
			return true;
		}

		private static bool TryGetTerrainBaseHeight(float x, float z, out float height)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (WorldGenerator.instance != null)
			{
				height = WorldGenerator.instance.GetHeight(x, z);
				return true;
			}
			if (Heightmap.GetHeight(new Vector3(x, 0f, z), ref height))
			{
				return true;
			}
			height = 0f;
			return false;
		}

		private static bool TryGetHeightmap(Vector2i zone, out Heightmap heightmap)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			heightmap = null;
			if ((Object)(object)ZoneSystem.instance == (Object)null || !ZoneSystem.instance.IsZoneLoaded(zone))
			{
				return false;
			}
			heightmap = Heightmap.FindHeightmap(ZoneSystem.GetZonePos(zone));
			return (Object)(object)heightmap != (Object)null;
		}

		private static float GetWorldHeight(Heightmap heightmap, int x, int z)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			return heightmap.GetHeight(x, z) + ((Component)heightmap).transform.position.y;
		}

		private static Color GetPaint(Heightmap heightmap, int x, int z)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.Clamp(x, 0, heightmap.m_width);
			int num2 = Mathf.Clamp(z, 0, heightmap.m_width);
			return heightmap.GetPaintMask(num, num2);
		}

		private static bool IsCompilerReady(TerrainComp compiler)
		{
			if ((Object)(object)compiler == (Object)null || (Object)(object)compiler.m_hmap == (Object)null)
			{
				return false;
			}
			ZNetView component = ((Component)compiler).GetComponent<ZNetView>();
			if ((Object)(object)component != (Object)null)
			{
				return component.IsValid();
			}
			return false;
		}

		private static bool IsValidPayloadIndex(int index, int width, int length)
		{
			if (width > 0 && index >= 0 && index < length)
			{
				return index < width * width;
			}
			return false;
		}

		private static void IndexToXZ(int index, int width, out int x, out int z)
		{
			z = index / width;
			x = index - z * width;
		}

		private static bool Approximately(Color a, Color b)
		{
			//IL_0000: 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)
			//IL_0019: 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_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: 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)
			if (Mathf.Abs(a.r - b.r) < 0.001f && Mathf.Abs(a.g - b.g) < 0.001f && Mathf.Abs(a.b - b.b) < 0.001f)
			{
				return Mathf.Abs(a.a - b.a) < 0.001f;
			}
			return false;
		}

		private static bool TryGetWearNTearWorldBounds(GameObject prefab, Vector3 position, Quaternion rotation, Vector3 scale, out Bounds bounds)
		{
			//IL_0002: 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_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)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: 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_0070: 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_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: 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)
			//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_00a0: 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)
			//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_00a7: Unknown result type (might be due to invalid IL or missing references)
			bounds = default(Bounds);
			Collider[] componentsInChildren = prefab.GetComponentsInChildren<Collider>();
			Matrix4x4 val = Matrix4x4.TRS(position, rotation, scale);
			bool flag = false;
			Collider[] array = componentsInChildren;
			foreach (Collider val2 in array)
			{
				if ((Object)(object)val2 == (Object)null || !val2.enabled || val2.isTrigger || !TryGetColliderLocalBounds(val2, out var bounds2))
				{
					continue;
				}
				Matrix4x4 val3 = prefab.transform.worldToLocalMatrix * ((Component)val2).transform.localToWorldMatrix;
				foreach (Vector3 boundsCorner in GetBoundsCorners(bounds2))
				{
					Vector3 val4 = ((Matrix4x4)(ref val)).MultiplyPoint3x4(((Matrix4x4)(ref val3)).MultiplyPoint3x4(boundsCorner));
					if (flag)
					{
						((Bounds)(ref bounds)).Encapsulate(val4);
						continue;
					}
					bounds = new Bounds(val4, Vector3.zero);
					flag = true;
				}
			}
			return flag;
		}

		private static bool TryGetColliderLocalBounds(Collider collider, out Bounds bounds)
		{
			//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_0048: 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_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_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_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_008f: 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)
			//IL_00bf: 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_00c5: 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_00f5: 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_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: 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)
			BoxCollider val = (BoxCollider)(object)((collider is BoxCollider) ? collider : null);
			if (val == null)
			{
				SphereCollider val2 = (SphereCollider)(object)((collider is SphereCollider) ? collider : null);
				if (val2 == null)
				{
					CapsuleCollider val3 = (CapsuleCollider)(object)((collider is CapsuleCollider) ? collider : null);
					if (val3 == null)
					{
						MeshCollider val4 = (MeshCollider)(object)((collider is MeshCollider) ? collider : null);
						if (val4 != null && (Object)(object)val4.sharedMesh != (Object)null)
						{
							bounds = val4.sharedMesh.bounds;
							return true;
						}
						Bounds bounds2 = collider.bounds;
						bounds = new Bounds(((Component)collider).transform.InverseTransformPoint(((Bounds)(ref bounds2)).center), ((Bounds)(ref bounds2)).size);
						return true;
					}
					Vector3 val5 = Vector3.one * (val3.radius * 2f);
					((Vector3)(ref val5))[val3.direction] = Mathf.Max(val3.height, val3.radius * 2f);
					bounds = new Bounds(val3.center, val5);
					return true;
				}
				bounds = new Bounds(val2.center, Vector3.one * (val2.radius * 2f));
				return true;
			}
			bounds = new Bounds(val.center, val.size);
			return true;
		}

		[IteratorStateMachine(typeof(<GetBoundsCorners>d__37))]
		private static IEnumerable<Vector3> GetBoundsCorners(Bounds bounds)
		{
			//IL_0008: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetBoundsCorners>d__37(-2)
			{
				<>3__bounds = bounds
			};
		}

		private static long PackCell(int x, int z)
		{
			return ((long)x << 32) ^ (uint)z;
		}

		private static Vector3 VertexToWorld(Heightmap heightmap, int x, int z)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)heightmap).transform.position;
			position.x += (float)(x - heightmap.m_width / 2) * heightmap.m_scale;
			position.z += (float)(z - heightmap.m_width / 2) * heightmap.m_scale;
			return position;
		}

		private static void WriteColor(ZPackage package, Color color)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			package.Write(color.r);
			package.Write(color.g);
			package.Write(color.b);
			package.Write(color.a);
		}

		private static Color ReadColor(ZPackage package)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			return new Color(package.ReadSingle(), package.ReadSingle(), package.ReadSingle(), package.ReadSingle());
		}
	}
	[HarmonyPatch(typeof(Heightmap), "ApplyModifiers")]
	internal static class HomesteadTerrainSupportBaseLayerPatch
	{
		private static void Prefix(Heightmap __instance)
		{
			HomesteadTerrainSupport.ApplyBaseLayer(__instance);
		}
	}
	internal static class HomesteadTimestamp
	{
		public static string Now()
		{
			return Format(DateTime.UtcNow);
		}

		public static string Format(DateTime utc)
		{
			if (utc == DateTime.MinValue)
			{
				return "";
			}
			return new DateTimeOffset(DateTime.SpecifyKind(utc, DateTimeKind.Utc)).ToLocalTime().ToString("yyyy-MM-dd HH:mm:ss zzz", CultureInfo.InvariantCulture);
		}

		public static DateTime ParseUtc(string value)
		{
			if (string.IsNullOrWhiteSpace(value))
			{
				return DateTime.MinValue;
			}
			if (DateTimeOffset.TryParse(value, CultureInfo.InvariantCulture, DateTimeStyles.AllowWhiteSpaces, out var result) || DateTimeOffset.TryParse(value, CultureInfo.CurrentCulture, DateTimeStyles.AllowWhiteSpaces, out result))
			{
				return DateTime.SpecifyKind(result.UtcDateTime, DateTimeKind.Utc);
			}
			if (DateTime.TryParse(value, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeLocal, out var result2) || DateTime.TryParse(value, CultureInfo.CurrentCulture, DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeLocal, out result2))
			{
				return DateTime.SpecifyKind(result2, DateTimeKind.Utc);
			}
			return DateTime.MinValue;
		}

		public static bool IsExpired(string timestamp, DateTime utcNow)
		{
			DateTime dateTime = ParseUtc(timestamp);
			if (dateTime != DateTime.MinValue)
			{
				return dateTime <= DateTime.SpecifyKind(utcNow, DateTimeKind.Utc);
			}
			return false;
		}
	}
	internal static class HomesteadYaml
	{
		private static readonly ISerializer Serializer = new SerializerBuilder().DisableAliases().ConfigureDefaultValuesHandling(DefaultValuesHandling.OmitNull).WithNamingConvention(CamelCaseNamingConvention.Instance)
			.WithTypeConverter(new FlowFloatArrayYamlConverter())
			.Build();

		private static readonly IDeserializer Deserializer = new DeserializerBuilder().IgnoreUnmatchedProperties().WithNamingConvention(CamelCaseNamingConvention.Instance).WithTypeConverter(new FlowFloatArrayYamlConverter())
			.Build();

		public static string Serialize<T>(T value)
		{
			return Serializer.Serialize(value);
		}

		public static T Deserialize<T>(string yaml)
		{
			return Deserializer.Deserialize<T>(yaml) ?? throw new InvalidDataException("Failed to deserialize " + typeof(T).Name + ".");
		}
	}
	internal sealed class FlowFloatArrayYamlConverter : IYamlTypeConverter
	{
		public bool Accepts(Type type)
		{
			return type == typeof(float[]);
		}

		public object ReadYaml(IParser parser, Type type, ObjectDeserializer rootDeserializer)
		{
			parser.Consume<SequenceStart>();
			List<float> list = new List<float>();
			SequenceEnd @event;
			while (!parser.TryConsume<SequenceEnd>(out @event))
			{
				YamlDotNet.Core.Events.Scalar scalar = parser.Consume<YamlDotNet.Core.Events.Scalar>();
				if (!float.TryParse(scalar.Value, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
				{
					Mark start = scalar.Start;
					Mark end = scalar.End;
					throw new YamlException(in start, in end, "Invalid float value '" + scalar.Value + "'.");
				}
				list.Add(result);
			}
			return list.ToArray();
		}

		public void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer)
		{
			float[] obj = (value as float[]) ?? Array.Empty<float>();
			emitter.Emit(new SequenceStart(AnchorName.Empty, TagName.Empty, isImplicit: true, SequenceStyle.Flow));
			float[] array = obj;
			foreach (float num in array)
			{
				emitter.Emit(new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, num.ToString("0.###", CultureInfo.InvariantCulture), ScalarStyle.Plain, isPlainImplicit: true, isQuotedImplicit: true));
			}
			emitter.Emit(new SequenceEnd());
		}
	}
	public static class ToggleExtensions
	{
		[SpecialName]
		public sealed class <G>$7EB8D39D0590F52339A917419F61209D
		{
			[SpecialName]
			public static class <M>$352DF56E54E9138FA9089CCF33D1E5A3
			{
			}

			[ExtensionMarker("<M>$352DF56E54E9138FA9089CCF33D1E5A3")]
			public bool IsOn()
			{
				throw new NotSupportedException();
			}

			[ExtensionMarker("<M>$352DF56E54E9138FA9089CCF33D1E5A3")]
			public bool IsOff()
			{
				throw new NotSupportedException();
			}
		}

		public static bool IsOn(this HomesteadPlugin.Toggle value)
		{
			return value == HomesteadPlugin.Toggle.On;
		}

		public static bool IsOff(this HomesteadPlugin.Toggle value)
		{
			return value == HomesteadPlugin.Toggle.Off;
		}
	}
	public enum BlueprintAzuCraftyBoxesPullMode
	{
		Off,
		ConfirmOnly,
		OpenAndConfirm
	}
	public enum BlueprintTerrainSupportMode
	{
		Off,
		On,
		AdminDebug
	}
	public enum BlueprintAreaSaveCreatorMode
	{
		AllCreators,
		OwnedAndCreatorless,
		OwnedOnly
	}
	public enum BlueprintStoreIdentityMode
	{
		PlayerId,
		SteamId
	}
	public enum BlueprintStoreNotificationMode
	{
		Off,
		BadgeOnly,
		AutoOpenPanel
	}
	public enum BuildCameraDistanceMode
	{
		Fixed,
		ComfortScaled
	}
	public enum BuildCameraRestrictionMode
	{
		Off,
		CameraNeedsCoziness,
		CameraPickUpNeedsCoziness
	}
	internal static class VersionHandshakeLogger
	{
		public static ManualLogSource Log => HomesteadPlugin.HomesteadLogger;
	}
	[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
	public static class RegisterAndCheckVersion
	{
		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
			VersionHandshakeLogger.Log.LogDebug((object)"Registering version RPC handler");
			peer.m_rpc.Register<ZPackage>("Homestead_VersionCheck", (Action<ZRpc, ZPackage>)RpcHandlers.RPC_ModVersion);
			VersionHandshakeLogger.Log.LogInfo((object)"Invoking version check");
			ZPackage val = new ZPackage();
			val.Write("1.0.5");
			peer.m_rpc.Invoke("Homestead_VersionCheck", new object[1] { val });
		}
	}
	[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;
			}
			VersionHandshakeLogger.Log.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;
		}
	}
	[HarmonyPatch(typeof(FejdStartup), "ShowConnectError")]
	public class ShowConnectionError
	{
		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" + HomesteadPlugin.ConnectionError;
			}
		}
	}
	[HarmonyPatch(typeof(ZNet), "Disconnect")]
	public static class RemoveDisconnectedPeerFromVerified
	{
		private static void Prefix(ZNetPeer peer, ref ZNet __instance)
		{
			if (__instance.IsServer())
			{
				VersionHandshakeLogger.Log.LogInfo((object)("Peer (" + peer.m_rpc.m_socket.GetHostName() + ") disconnected, removing from validated list"));
				RpcHandlers.ValidatedPeers.Remove(peer.m_rpc);
			}
		}
	}
	public static class RpcHandlers
	{
		public static readonly List<ZRpc> ValidatedPeers = new List<ZRpc>();

		public static void RPC_ModVersion(ZRpc rpc, ZPackage pkg)
		{
			string text = pkg.ReadString();
			VersionHandshakeLogger.Log.LogInfo((object)("Version check, local: 1.0.5,  remote: " + text));
			if (text != "1.0.5")
			{
				HomesteadPlugin.ConnectionError = "Homestead Installed: 1.0.5\n Needed: " + text;
				if (ZNet.instance.IsServer())
				{
					VersionHandshakeLogger.Log.LogWarning((object)("Peer (" + rpc.m_socket.GetHostName() + ") has incompatible version, disconnecting..."));
					rpc.Invoke("Error", new object[1] { 3 });
				}
			}
			else if (!ZNet.instance.IsServer())
			{
				VersionHandshakeLogger.Log.LogInfo((object)"Received same version from server!");
			}
			else
			{
				VersionHandshakeLogger.Log.LogInfo((object)("Adding peer (" + rpc.m_socket.GetHostName() + ") to validated list"));
				ValidatedPeers.Add(rpc);
			}
		}
	}
	internal static class ZoneAreaCameraZoomGuard
	{
		[HarmonyPatch(typeof(GameCamera), "UpdateCamera")]
		private static class GameCameraUpdateCameraPatch
		{
			private static void Prefix(GameCamera __instance)
			{
				if (_suppressFrame == Time.frameCount)
				{
					_distance = __instance.m_distance;
					_zoomSensitivity = __instance.m_zoomSens;
					__instance.m_zoomSens = 0f;
				}
			}

			private static void Postfix(GameCamera __instance)
			{
				if (_suppressFrame == Time.frameCount)
				{
					__instance.m_zoomSens = _zoomSensitivity;
					__instance.m_distance = _distance;
				}
			}
		}

		private static int _suppressFrame = -1;

		private static float _distance;

		private static float _zoomSensitivity;

		public static void SuppressWheelZoomThisFrame()
		{
			if (!((Object)(object)GameCamera.instance == (Object)null) && _suppressFrame != Time.frameCount)
			{
				_distance = GameCamera.instance.m_distance;
				_zoomSensitivity = GameCamera.instance.m_zoomSens;
				_suppressFrame = Time.frameCount;
			}
		}
	}
	internal sealed class ZoneAreaToolController
	{
		internal sealed class Options
		{
			public float MinSide { get; set; }

			public float SizeStep { get; set; }

			public Func<float> MaxSide { get; set; }

			public Func<float> DefaultWidth { get; set; }

			public Func<float> DefaultDepth { get; set; }

			public Func<Color> Color { get; set; }

			public string RangeLineName { get; set; } = "";


			public string TargetOverlayName { get; set; } = "";


			public float TargetOverlayRefreshInterval { get; set; } = 0.12f;


			public float StableTargetOverlayRefreshInterval { get; set; } = 1f;


			public Func<float?> GetSavedYaw { get; set; } = () => null;


			public Action<float> SetSavedYaw { get; set; } = delegate
			{
			};


			public Func<bool> IsLocked { get; set; } = () => false;


			public Func<float, float>? GetEffectiveYaw { get; set; }

			public Action<float>? OnLockedScroll { get; set; }

			public Action<Player>? OnFrame { get; set; }

			public Func<bool> ShouldBlockToolInput { get; set; } = () => false;


			public Func<string> StatusTitle { get; set; } = () => "";


			public Func<Player, ZoneAreaSelection, IReadOnlyList<ZDO>> FindCandidates { get; set; } = (Player _, ZoneAreaSelection _) => Array.Empty<ZDO>();


			public Action<Player, ZoneAreaSelection> OnClick { get; set; } = delegate
			{
			};

		}

		private readonly MonoBehaviour _owner;

		private readonly Options _options;

		private LineRenderer? _rangeLine;

		private ZoneAreaTargetOverlay? _targetOverlay;

		private Material? _material;

		private bool _active;

		private float _width;

		private float _depth;

		private float _yaw;

		private float _heightOffset;

		private Vector3 _horizontalOffset;

		private Vector3 _aimPoint;

		private Vector3 _rawAimPoint;

		private bool _hasAimPoint;

		private int _suppressInputFrames;

		private float _lastTargetOverlayRefreshTime = -999f;

		private int _lastTargetOverlaySignature;

		private bool _hasTargetOverlaySignature;

		public bool Active => _active;

		public bool HasAimPoint => _hasAimPoint;

		public Vector3 AimPoint => _aimPoint;

		public float EffectiveYaw => GetEffectiveYaw();

		public Vector3 HorizontalOffset => _horizontalOffset;

		public float HeightOffset => _heightOffset;

		public ZoneAreaSelection CurrentArea => ZoneAreaToolShared.BuildArea(_aimPoint, ref _width, ref _depth, _yaw, _options.DefaultWidth(), _options.DefaultDepth(), _options.MinSide, _options.MaxSide());

		public string FormattedSize => ZoneAreaToolShared.FormatSize(_width, _depth);

		public ZoneAreaToolController(MonoBehaviour owner, Options options)
		{
			_owner = owner;
			_options = options;
		}

		public void Activate(Player player)
		{
			//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_00a0: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			if (!_active)
			{
				_width = Mathf.Clamp(_options.DefaultWidth(), _options.MinSide, _options.MaxSide());
				_depth = Mathf.Clamp(_options.DefaultDepth(), _options.MinSide, _options.MaxSide());
				float? num = _options.GetSavedYaw();
				float yaw;
				if (!num.HasValue)
				{
					Quaternion rotation = ((Component)player).transform.rotation;
					yaw = ZoneAreaSelection.NormalizeYaw(((Quaternion)(ref rotation)).eulerAngles.y);
				}
				else
				{
					yaw = num.GetValueOrDefault();
				}
				_yaw = yaw;
				_heightOffset = 0f;
				_horizontalOffset = Vector3.zero;
			}
			_active = true;
			_hasAimPoint = false;
			_suppressInputFrames = 2;
			EnsureRangeLine();
		}

		public void Deactivate()
		{
			_active = false;
			ResetOffsets();
			ClearTargetOverlay();
			ZoneAreaToolStatusHud.Hide();
			HideRange();
		}

		public void ResetOffsets()
		{
			//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)
			_heightOffset = 0f;
			_horizontalOffset = Vector3.zero;
		}

		public void Destroy()
		{
			_targetOverlay?.Destroy();
			_targetOverlay = null;
			if ((Object)(object)_material != (Object)null)
			{
				Object.Destroy((Object)(object)_material);
				_material = null;
			}
		}

		public bool Tick()
		{
			//IL_0058: 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_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			if (!_active)
			{
				return true;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || !ZoneAreaToolShared.IsHoldingBuildTool(localPlayer))
			{
				return false;
			}
			if (!ZoneAreaToolShared.TryGetAimPoint(localPlayer, _options.MaxSide(), out var point))
			{
				_hasAimPoint = false;
				HideRange();
				ClearTargetOverlay();
				ZoneAreaToolStatusHud.Hide();
				return true;
			}
			_rawAimPoint = point;
			_aimPoint = GetAdjustedAimPoint(point);
			_hasAimPoint = true;
			bool flag = _options.IsLocked();
			if (flag)
			{
				HideRange();
				ClearTargetOverlay();
			}
			else
			{
				DrawRange();
				UpdateTargetOverlay(localPlayer);
			}
			_options.OnFrame?.Invoke(localPlayer);
			UpdateStatusHud();
			if (ZoneAreaToolShared.ShouldBlockInput())
			{
				return true;
			}
			if (_suppressInputFrames > 0)
			{
				_suppressInputFrames--;
				return true;
			}
			if (_options.ShouldBlockToolInput())
			{
				return true;
			}
			HandleScroll(flag);
			HandleOffset();
			UpdateStatusHud();
			if (!flag && Input.GetMouseButtonDown(0))
			{
				_options.OnClick(localPlayer, CurrentArea);
			}
			return true;
		}

		private void HandleScroll(bool locked)
		{
			float axis = Input.GetAxis("Mouse ScrollWheel");
			if (Mathf.Abs(axis) <= 0.001f)
			{
				return;
			}
			ZoneAreaCameraZoomGuard.SuppressWheelZoomThisFrame();
			if (locked && _options.OnLockedScroll != null)
			{
				_options.OnLockedScroll(axis);
				return;
			}
			float delta = ((axis > 0f) ? _options.SizeStep : (0f - _options.SizeStep));
			if (PlacementControlConfig.IsAreaDepthModifierHeld())
			{
				ZoneAreaToolShared.ResizeDepth(ref _depth, delta, _options.MinSide, _options.MaxSide());
				ClearTargetOverlay();
				return;
			}
			if (PlacementControlConfig.IsAreaWidthModifierHeld())
			{
				ZoneAreaToolShared.ResizeWidth(ref _width, delta, _options.MinSide, _options.MaxSide());
				ClearTargetOverlay();
				return;
			}
			if (PlacementControlConfig.IsAreaUniformScaleModifierHeld())
			{
				ZoneAreaToolShared.ResizeUniform(ref _width, ref _depth, delta, _options.MinSide, _options.MaxSide());
				ClearTargetOverlay();
				return;
			}
			float num = ((axis > 0f) ? PlacementControlConfig.RotationStep : (0f - PlacementControlConfig.RotationStep));
			_yaw = ZoneAreaSelection.NormalizeYaw(_yaw + num);
			_options.SetSavedYaw(_yaw);
			ClearTargetOverlay();
		}

		private void HandleOffset()
		{
			//IL_0063: 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_0068: 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_007e: 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_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_009c: 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_00a6: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			if (PlacementControlConfig.IsPlacementAdjustModifierHeld() && (Input.GetKeyDown((KeyCode)280) || Input.GetKeyDown((KeyCode)281)))
			{
				float num = (Input.GetKeyDown((KeyCode)280) ? 1f : (-1f));
				_heightOffset = ZoneAreaToolShared.RoundOffset(_heightOffset + num * PlacementControlConfig.HeightStep);
				flag = true;
			}
			Vector3 val = (PlacementControlConfig.IsPlacementAdjustModifierHeld() ? ZonePlacementOffset.GetArrowKeyLocalNudge() : Vector3.zero);
			if (((Vector3)(ref val)).sqrMagnitude > 0.0001f)
			{
				_horizontalOffset += val * PlacementControlConfig.HorizontalStep;
				flag = true;
			}
			if (flag)
			{
				_aimPoint = GetAdjustedAimPoint(_rawAimPoint);
				ClearTargetOverlay();
			}
		}

		private Vector3 GetAdjustedAimPoint(Vector3 rawAimPoint)
		{
			//IL_0000: 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_0013: Unknown result type (might be due to invalid IL or missing references)
			return ZoneAreaToolShared.GetAdjustedAimPoint(rawAimPoint, GetEffectiveYaw(), _horizontalOffset, _heightOffset);
		}

		private float GetEffectiveYaw()
		{
			return _options.GetEffectiveYaw?.Invoke(_yaw) ?? _yaw;
		}

		private void DrawRange()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			EnsureRangeLine();
			if (!((Object)(object)_rangeLine == (Object)null))
			{
				ZoneAreaToolShared.DrawGroundRectangle(_rangeLine, CurrentArea, _aimPoint, _heightOffset, _options.Color());
			}
		}

		private void UpdateTargetOverlay(Player player)
		{
			if (ZDOMan.instance == null || (Object)(object)ZNetScene.instance == (Object)null)
			{
				return;
			}
			ZoneAreaSelection currentArea = CurrentArea;
			int num = BuildTargetOverlaySignature(currentArea);
			bool num2 = !_hasTargetOverlaySignature || num != _lastTargetOverlaySignature;
			float time = Time.time;
			float num3 = (num2 ? _options.TargetOverlayRefreshInterval : Mathf.Max(_options.TargetOverlayRefreshInterval, _options.StableTargetOverlayRefreshInterval));
			if (!(time - _lastTargetOverlayRefreshTime < num3))
			{
				_lastTargetOverlaySignature = num;
				_hasTargetOverlaySignature = true;
				_lastTargetOverlayRefreshTime = time;
				if (_targetOverlay == null)
				{
					_targetOverlay = new ZoneAreaTargetOverlay(((Component)_owner).transform, _options.TargetOverlayName);
				}
				_targetOverlay.Draw(_options.FindCandidates(player, currentArea), currentArea);
			}
		}

		private void ClearTargetOverlay()
		{
			_targetOverlay?.Clear();
			_lastTargetOverlayRefreshTime = -999f;
			_hasTargetOverlaySignature = false;
		}

		private static int BuildTargetOverlaySignature(ZoneAreaSelection area)
		{
			//IL_0007: 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)
			return ((((17 * 31 + Mathf.RoundToInt(area.Center.x * 2f)) * 31 + Mathf.RoundToInt(area.Center.z * 2f)) * 31 + Mathf.RoundToInt(area.Width * 2f)) * 31 + Mathf.RoundToInt(area.Depth * 2f)) * 31 + Mathf.RoundToInt(area.Yaw * 10f);
		}

		private void UpdateStatusHud()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			ZoneAreaToolStatusHud.Show(_options.StatusTitle(), FormattedSize, GetEffectiveYaw(), _horizontalOffset, _heightOffset);
		}

		private void EnsureRangeLine()
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_rangeLine != (Object)null))
			{
				EnsureMaterial();
				_rangeLine = ZoneAreaToolShared.CreateLineRenderer(((Component)_owner).transform, _options.RangeLineName, 0.12f, _options.Color(), _material);
				((Renderer)_rangeLine).enabled = false;
			}
		}

		private void EnsureMaterial()
		{
			if (_material == null)
			{
				_material = ZoneAreaToolShared.CreateLineMaterial();
			}
		}

		private void HideRange()
		{
			if ((Object)(object)_rangeLine != (Object)null)
			{
				((Renderer)_rangeLine).enabled = false;
			}
		}
	}
	internal sealed class ZoneAreaDismantleTool : MonoBehaviour
	{
		private readonly struct DismantleTarget
		{
			public ZDO Zdo { get; }

			public GameObject Prefab { get; }

			public DismantleTarget(ZDO zdo, GameObject prefab)
			{
				Zdo = zdo;
				Prefab = prefab;
			}
		}

		private sealed class MaterialRefund
		{
			public string PrefabName { get; }

			public string DisplayName { get; }

			public ItemData Prototype { get; }

			public GameObject DropPrefab { get; }

			public int Amount { get; set; }

			public MaterialRefund(string prefabName, string displayName, ItemData prototype, GameObject dropPrefab)
			{
				PrefabName = prefabName;
				DisplayName = displayName;
				Prototype = prototype;
				DropPrefab = dropPrefab;
			}
		}

		private readonly struct DismantleResult
		{
			public bool Success { get; }

			public string Message { get; }

			public bool PlayDestroySfx { get; }

			public Vector3 EffectPosition { get; }

			public DismantleResult(bool success, string message, bool playDestroySfx = false, Vector3 effectPosition = default(Vector3))
			{
				//IL_0016: 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)
				Success = success;
				Message = message;
				PlayDestroySfx = playDestroySfx;
				EffectPosition = effectPosition;
			}

			public static DismantleResult Ok(string message, Vector3 effectPosition)
			{
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				return new DismantleResult(success: true, message, playDestroySfx: true, effectPosition);
			}

			public static DismantleResult Fail(string message)
			{
				//IL_0005: 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)
				return new DismantleResult(success: false, message);
			}
		}

		private const float MinSideLength = 1f;

		private const float SizeStep = 1f;

		private const float TargetOverlayRefreshInterval = 0.3f;

		private const float RequestCooldownSeconds = 1f;

		private const float RequestCooldownCleanupSeconds = 60f;

		private const string RequestRpcName = "sighsorry.Homestead_AreaDismantleRequest";

		private const string ResultRpcName = "sighsorry.Homestead_AreaDismantleResult";

		private const string DestroySfxPrefab = "sfx_wood_destroyed";

		private static ManualLogSource? _logger;

		private static ZoneAreaDismantleTool? _instance;

		private static readonly ZoneRpcRegistrar RpcRegistrar = new ZoneRpcRegistrar();

		private static float? _lastAreaYaw;

		private static readonly Dictionary<long, float> NextRequestAtBySender = new Dictionary<long, float>();

		private static float _nextCooldownCleanup;

		private readonly List<ZDO> _nearbyTargetZdos = new List<ZDO>();

		private readonly List<ZDO> _targetCandidateZdos = new List<ZDO>();

		private ZoneAreaToolController? _areaTool;

		private bool _active;

		private static float MaxSelectableSide => Mathf.Max(1f, AreaToolConfig.DismantleMaxSide);

		public static bool IsActive
		{
			get
			{
				ZoneAreaDismantleTool? instance = _instance;
				if (instance == null)
				{
					return false;
				}
				return (instance._areaTool?.Active).GetValueOrDefault();
			}
		}

		private ZoneAreaToolController AreaTool => _areaTool ?? (_areaTool = new ZoneAreaToolController((MonoBehaviour)(object)this, new ZoneAreaToolController.Options
		{
			MinSide = 1f,
			SizeStep = 1f,
			MaxSide = () => MaxSelectableSide,
			DefaultWidth = () => AreaToolConfig.DismantleDefaultWidth,
			DefaultDepth = () => AreaToolConfig.DismantleDefaultDepth,
			Color = () => AreaToolConfig.DismantleColor,
			RangeLineName = "HomesteadAreaDismantleRadius",
			TargetOverlayName = "HomesteadAreaDismantleTarget",
			TargetOverlayRefreshInterval = 0.3f,
			GetSavedYaw = () => _lastAreaYaw,
			SetSavedYaw = delegate(float yaw)
			{
				_lastAreaYaw = yaw;
			},
			StatusTitle = () => HomesteadLocalization.Text("hs_area_dismantle_name"),
			FindCandidates = FindDismantlePreviewCandidates,
			OnClick = RequestDismantle
		}));

		public static void Initialize(ManualLogSource logger)
		{
			_logger = logger;
			EnsureInstance();
			RegisterRpcs();
		}

		internal static void RegisterRpcs()
		{
			RpcRegistrar.EnsureRegistered(delegate(ZRoutedRpc routedRpc)
			{
				routedRpc.Register<ZPackage>("sighsorry.Homestead_AreaDismantleRequest", (Action<long, ZPackage>)RPC_HandleRequest);
				routedRpc.Register<ZPackage>("sighsorry.Homestead_AreaDismantleResult", (Action<long, ZPackage>)RPC_HandleResult);
			});
		}

		public static void Activate(Player player)
		{
			EnsureInstance();
			_instance?.ActivateInternal(player);
		}

		public static void Deactivate()
		{
			_instance?.DeactivateInternal();
		}

		private static void EnsureInstance()
		{
			//IL_001f: 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_002a: Expected O, but got Unknown
			if (!((Object)(object)_instance != (Object)null) || !Object.op_Implicit((Object)(object)_instance))
			{
				GameObject val = new GameObject("HomesteadAreaDismantleTool");
				Object.DontDestroyOnLoad((Object)val);
				_instance = val.AddComponent<ZoneAreaDismantleTool>();
			}
		}

		private void ActivateInternal(Player player)
		{
			_active = true;
			AreaTool.Activate(player);
		}

		private void DeactivateInternal()
		{
			_active = false;
			_areaTool?.Deactivate();
		}

		private void Update()
		{
			if (!_active)
			{
				ZoneAreaToolController? areaTool = _areaTool;
				if (areaTool == null || !areaTool.Active)
				{
					return;
				}
			}
			if (!AreaTool.Tick())
			{
				DeactivateInternal();
			}
		}

		private void OnDestroy()
		{
			_areaTool?.Destroy();
			_areaTool = null;
			if ((Object)(object)_instance == (Object)(object)this)
			{
				_instance = null;
			}
		}

		private void RequestDismantle(Player player)
		{
			RequestDismantle(player, AreaTool.CurrentArea);
		}

		private void RequestDismantle(Player player, ZoneAreaSelection area)
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			//IL_0086: 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)
			if (!AreaTool.HasAimPoint)
			{
				return;
			}
			if ((Object)(object)ZNet.instance == (Object)null || ZDOMan.instance == null)
			{
				ShowResult(DismantleResult.Fail(HomesteadLocalization.Text("hs_common_world_not_ready")));
				return;
			}
			if (ZNet.instance.IsServer())
			{
				long playerID = player.GetPlayerID();
				if (!TryReserveLocalRequest(playerID, out string reason))
				{
					ShowResult(DismantleResult.Fail(reason));
				}
				else
				{
					ShowResult(ExecuteDismantle(playerID, ((Component)player).transform.position, area));
				}
				return;
			}
			RegisterRpcs();
			ZPackage val = new ZPackage();
			val.Write(area.Center);
			val.Write(area.Width);
			val.Write(area.Depth);
			val.Write(area.Yaw);
			ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "sighsorry.Homestead_AreaDismantleRequest", new object[1] { val });
		}

		private static void RPC_HandleRequest(long sender, ZPackage package)
		{
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Expected O, but got Unknown
			//IL_00da: 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_0034: 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_0069: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			DismantleResult dismantleResult;
			try
			{
				if (!TryReserveRequest(sender, out string reason))
				{
					dismantleResult = DismantleResult.Fail(reason);
				}
				else
				{
					Vector3 center = package.ReadVector3();
					float width = package.ReadSingle();
					float depth = package.ReadSingle();
					float yaw = package.ReadSingle();
					dismantleResult = (TryResolveRemotePlayer(sender, out long playerId, out Vector3 playerPosition, out string reason2) ? ExecuteDismantle(playerId, playerPosition, new ZoneAreaSelection(center, width, depth, yaw)) : DismantleResult.Fail(reason2));
				}
			}
			catch (Exception ex)
			{
				ManualLogSource? logger = _logger;
				if (logger != null)
				{
					logger.LogError((object)$"Area dismantle RPC failed: {ex}");
				}
				dismantleResult = DismantleResult.Fail(ex.Message);
			}
			ZPackage val = new ZPackage();
			val.Write(dismantleResult.Success);
			val.Write(dismantleResult.Message);
			val.Write(dismantleResult.PlayDestroySfx);
			val.Write(dismantleResult.EffectPosition);
			ZRoutedRpc.instance.InvokeRoutedRPC(sender, "sighsorry.Homestead_AreaDismantleResult", new object[1] { val });
		}

		private static bool TryReserveRequest(long sender, out string reason)
		{
			reason = "";
			if (sender == 0L)
			{
				return true;
			}
			float now = Time.realtimeSinceStartup;
			if (now >= _nextCooldownCleanup)
			{
				_nextCooldownCleanup = now + 60f;
				foreach (long item in (from pair in NextRequestAtBySender
					where pair.Value <= now
					select pair.Key).ToList())
				{
					NextRequestAtBySender.Remove(item);
				}
			}
			if (NextRequestAtBySender.TryGetValue(sender, out var value) && now < value)
			{
				reason = HomesteadLocalization.Text("hs_dismantle_rpc_cooldown");
				return false;
			}
			NextRequestAtBySender[sender] = now + 1f;
			return true;
		}

		private static bool TryReserveLocalRequest(long playerId, out string reason)
		{
			reason = "";
			if (playerId == 0L)
			{
				return true;
			}
			return TryReserveRequest((playerId > 0) ? (-playerId) : playerId, out reason);
		}

		private static void RPC_HandleResult(long sender, ZPackage package)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)ZNet.instance != (Object)null) || !ZNet.instance.IsServer())
			{
				ShowResult(new DismantleResult(package.ReadBool(), package.ReadString(), package.ReadBool(), package.ReadVector3()));
			}
		}

		private IReadOnlyList<ZDO> FindDismantlePreviewCandidates(Player player, ZoneAreaSelection area)
		{
			_targetCandidateZdos.Clear();
			if (ZDOMan.instance == null || (Object)(object)ZNetScene.instance == (Object)null || (Object)(object)player == (Object)null)
			{
				return _targetCandidateZdos;
			}
			long playerID = player.GetPlayerID();
			if (playerID == 0L)
			{
				return _targetCandidateZdos;
			}
			HashSet<string> areaDismantlePrefabBlacklist = BlueprintConfig.AreaDismantlePrefabBlacklist;
			ZoneAreaTargetOverlay.CollectNearbyZdos(area, _nearbyTargetZdos);
			foreach (ZDO nearbyTargetZdo in _nearbyTargetZdos)
			{
				if (!ZoneBlueprintCommands.IsHomesteadBlueprintChest(nearbyTargetZdo) && nearbyTargetZdo.GetLong(ZDOVars.s_creator, 0L) == playerID && ZoneBlueprintCommands.TryReadWearNTear(nearbyTargetZdo, out GameObject prefab) && IsLoadedWearNTear(nearbyTargetZdo))
				{
					string prefabName = Utils.GetPrefabName(prefab);
					if (!areaDismantlePrefabBlacklist.Contains(prefabName) && !HasProtectedContentsOrAttachments(nearbyTargetZdo, prefab))
					{
						_targetCandidateZdos.Add(nearbyTargetZdo);
					}
				}
			}
			return _targetCandidateZdos;
		}

		private static bool IsLoadedWearNTear(ZDO zdo)
		{
			if ((Object)(object)ZNetScene.instance == (Object)null)
			{
				return false;
			}
			ZNetView val = ZNetScene.instance.FindInstance(zdo);
			if ((Object)(object)val != (Object)null)
			{
				return (Object)(object)((Component)val).GetComponent<WearNTear>() != (Object)null;
			}
			return false;
		}

		private static DismantleResult ExecuteDismantle(long playerId, Vector3 playerPosition, ZoneAreaSelection area)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
			if (ZDOMan.instance == null || (Object)(object)ZNetScene.instance == (Object)null)
			{
				return DismantleResult.Fail(HomesteadLocalization.Text("hs_common_world_not_ready"));
			}
			if (playerId == 0L)
			{
				return DismantleResult.Fail(HomesteadLocalization.Text("hs_dismantle_playerid_missing"));
			}
			float maxSelectableSide = MaxSelectableSide;
			area = area.Clamp(1f, maxSelectableSide);
			if (HorizontalDistance(area.Center, playerPosition) > area.HalfDiagonal + maxSelectableSide + 16f)
			{
				return DismantleResult.Fail(HomesteadLocalization.Text("hs_dismantle_too_far"));
			}
			List<DismantleTarget> list = new List<DismantleTarget>();
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			HashSet<string> areaDismantlePrefabBlacklist = BlueprintConfig.AreaDismantlePrefabBlacklist;
			List<ZDO> list2 = new List<ZDO>();
			ZoneAreaTargetOverlay.CollectNearbyZdos(area, list2);
			foreach (ZDO item in list2)
			{
				if (!ZoneBlueprintCommands.TryReadWearNTear(item, out GameObject prefab))
				{
					continue;
				}
				string prefabName = Utils.GetPrefabName(prefab);
				if (area.Contains(item.GetPosition()))
				{
					if (ZoneBlueprintCommands.IsHomesteadBlueprintChest(item))
					{
						num2++;
					}
					else if (areaDismantlePrefabBlacklist.Contains(prefabName) || ZoneBlueprintCommands.IsHomesteadBlueprintChestPrefab(prefab))
					{
						num2++;
					}
					else if (item.GetLong(ZDOVars.s_creator, 0L) != playerId)
					{
						num++;
					}
					else if (HasProtectedContentsOrAttachments(item, prefab))
					{
						num3++;
					}
					else
					{
						list.Add(new DismantleTarget(item, prefab));
					}
				}
			}
			if (list.Count == 0)
			{
				string text = BuildSkippedMessage(num, num2, num3, verbose: true);
				return DismantleResult.Fail(HomesteadLocalization.Format("hs_dismantle_no_owned", Mathf.RoundToInt(area.Width), Mathf.RoundToInt(area.Depth), text));
			}
			Dictionary<string, MaterialRefund> dictionary = new Dictionary<string, MaterialRefund>();
			foreach (DismantleTarget item2 in list)
			{
				CollectRefundMaterials(item2.Prefab, dictionary);
			}
			int num4 = 0;
			foreach (DismantleTarget item3 in list)
			{
				if (item3.Zdo != null && item3.Zdo.IsValid())
				{
					SavedZdoHelper.Destroy(item3.Zdo);
					num4++;
				}
			}
			SavedZdoHelper.FlushDestroyed();
			int num5 = dictionary.Values.Sum((MaterialRefund refund) => refund.Amount);
			int num6 = DropRefundStacks(dictionary.Values, area.Center);
			string text2 = BuildSkippedMessage(num, num2, num3, verbose: false);
			return DismantleResult.Ok(HomesteadLocalization.Format("hs_dismantle_done", num4, num5, num6, text2), area.Center);
		}

		private static string BuildSkippedMessage(int skippedNotOwned, int skippedBlacklisted, int skippedWithContents, bool verbose)
		{
			List<string> list = new List<string>();
			if (skippedNotOwned > 0)
			{
				list.Add(verbose ? HomesteadLocalization.Format("hs_dismantle_skipped_not_owned_verbose", skippedNotOwned) : HomesteadLocalization.Format("hs_dismantle_skipped_not_owned_short", skippedNotOwned));
			}
			if (skippedBlacklisted > 0)
			{
				list.Add(verbose ? HomesteadLocalization.Format("hs_dismantle_skipped_blacklisted_verbose", skippedBlacklisted) : HomesteadLocalization.Format("hs_dismantle_skipped_blacklisted_short", skippedBlacklisted));
			}
			if (skippedWithContents > 0)
			{
				list.Add(verbose ? HomesteadLocalization.Format("hs_dismantle_skipped_contents_verbose", skippedWithContents) : HomesteadLocalization.Format("hs_dismantle_skipped_contents_short", skippedWithContents));
			}
			if (list.Count != 0)
			{
				return HomesteadLocalization.Format("hs_dismantle_skipped_suffix", string.Join(", ", list));
			}
			return "";
		}

		private static bool HasProtectedContentsOrAttachments(ZDO zdo, GameObject prefab)
		{
			if ((Object)(object)prefab.GetComponent<Container>() != (Object)null && HasContainerItems(zdo))
			{
				return true;
			}
			if ((Object)(object)prefab.GetComponent<ItemStand>() != (Object)null && !string.IsNullOrEmpty(zdo.GetString(ZDOVars.s_item, "")))
			{
				return true;
			}
			ArmorStand component = prefab.GetComponent<ArmorStand>();
			if ((Object)(object)component != (Object)null)
			{
				int num = Mathf.Max(component.m_slots?.Count ?? 0, 32);
				for (int i = 0; i < num; i++)
				{
					if (!string.IsNullOrEmpty(zdo.GetString(i + "_item", "")))
					{
						return true;
					}
				}
			}
			return false;
		}

		private static bool HasContainerItems(ZDO zdo)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			string @string = zdo.GetString(ZDOVars.s_items, "");
			if (!string.IsNullOrEmpty(@string))
			{
				try
				{
					ZPackage val = new ZPackage(@string);
					val.ReadInt();
					return val.ReadInt() > 0;
				}
				catch
				{
					return true;
				}
			}
			ZNetScene instance = ZNetScene.instance;
			ZNetView val2 = ((instance != null) ? instance.FindInstance(zdo) : null);
			Container val3 = (((Object)(object)val2 != (Object)null) ? ((Component)val2).GetComponent<Container>() : null);
			if ((Object)(object)val3 == (Object)null)
			{
				return false;
			}
			try
			{
				val3.Load();
			}
			catch
			{
			}
			Inventory inventory = val3.GetInventory();
			if (inventory == null)
			{
				return false;
			}
			return inventory.NrOfItems() > 0;
		}

		private static bool TryResolveRemotePlayer(long sender, out long playerId, out Vector3 playerPosition, out string reason)
		{
			//IL_0005: 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_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_007b: Unknown result type (might be due to invalid IL or missing references)
			playerId = 0L;
			playerPosition = Vector3.zero;
			reason = "";
			if ((Object)(object)ZNet.instance == (Object)null || ZDOMan.instance == null)
			{
				reason = "World is not ready.";
				return false;
			}
			ZNetPeer peer = ZNet.instance.GetPeer(sender);
			if (peer == null || !peer.IsReady())
			{
				reason = "Player is not ready.";
				return false;
			}
			playerPosition = peer.m_refPos;
			if (((ZDOID)(ref peer.m_characterID)).IsNone())
			{
				reason = "Could not resolve your character.";
				return false;
			}
			ZDO zDO = ZDOMan.instance.GetZDO(peer.m_characterID);
			playerId = ((zDO != null) ? zDO.GetLong(ZDOVars.s_playerID, 0L) : 0);
			if (playerId == 0L)
			{
				reason = "Could not resolve your playerID.";
				return false;
			}
			return true;
		}

		private static void CollectRefundMaterials(GameObject prefab, Dictionary<string, MaterialRefund> refunds)
		{
			Piece component = prefab.GetComponent<Piece>();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			Requirement[] resources = component.m_resources;
			foreach (Requirement val in resources)
			{
				if (!Object.op_Implicit((Object)(object)val.m_resItem) || val.m_amount <= 0 || !val.m_recover)
				{
					continue;
				}
				int amount = val.GetAmount(0);
				if (amount > 0)
				{
					string prefabName = Utils.GetPrefabName(((Component)val.m_resItem).gameObject);
					if (!refunds.TryGetValue(prefabName, out MaterialRefund value))
					{
						value = (refunds[prefabName] = new MaterialRefund(prefabName, val.m_resItem.m_itemData.m_shared.m_name, val.m_resItem.m_itemData, ((Component)val.m_resItem).gameObject));
					}
					value.Amount += amount;
				}
			}
		}

		private static int DropRefundStacks(IEnumerable<MaterialRefund> refunds, Vector3 dropPosition)
		{
			//IL_006b: 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_007a: 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_0089: 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_0095: 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_009d: 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)
			int num = 0;
			foreach (MaterialRefund refund in refunds)
			{
				if (refund.Amount > 0)
				{
					int num2 = Mathf.Max(1, refund.Prototype.m_shared.m_maxStackSize);
					int num3 = refund.Amount;
					while (num3 > 0)
					{
						int num4 = Mathf.Min(num3, num2);
						ItemData obj = refund.Prototype.Clone();
						obj.m_stack = num4;
						obj.m_dropPrefab = refund.DropPrefab;
						Vector2 val = Random.insideUnitCircle * 0.8f;
						Vector3 val2 = dropPosition + new Vector3(val.x, 0.85f, val.y);
						ItemDrop.DropItem(obj, 0, val2, Random.rotation);
						num3 -= num4;
						num++;
					}
				}
			}
			return num;
		}

		private static float HorizontalDistance(Vector3 a, Vector3 b)
		{
			//IL_0000: 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)
			//IL_000d: 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)
			float num = a.x - b.x;
			float num2 = a.z - b.z;
			return Mathf.Sqrt(num * num + num2 * num2);
		}

		private static void ShowResult(DismantleResult result)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			ManualLogSource? logger = _logger;
			if (logger != null)
			{
				logger.LogInfo((object)result.Message);
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null)
			{
				((Character)localPlayer).Message((MessageType)(result.Success ? 1 : 2), result.Message, 0, (Sprite)null);
			}
			if (result.PlayDestroySfx)
			{
				PlayDestroySfx(result.EffectPosition);
			}
		}

		private static void PlayDestroySfx(Vector3 position)
		{
			//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)
			ZNetScene instance = ZNetScene.instance;
			GameObject val = ((instance != null) ? instance.GetPrefab("sfx_wood_destroyed") : null);
			if (Object.op_Implicit((Object)(object)val))
			{
				Object.Instantiate<GameObject>(val, position, Quaternion.identity);
			}
		}

		private static void Message(Player player, string message)
		{
			ManualLogSource? logger = _logger;
			if (logger != null)
			{
				logger.LogInfo((object)message);
			}
			((Character)player).Message((MessageType)1, message, 0, (Sprite)null);
		}
	}
	internal readonly struct ZoneAreaSelection
	{
		public Vector3 Center { get; }

		public float Width { get; }

		public float Depth { get; }

		public float Yaw { get; }

		public float MaxSide => Mathf.Max(Width, Depth);

		public float HalfDiagonal => Mathf.Sqrt(Width * Width + Depth * Depth) * 0.5f;

		public Quaternion Rotation => Quaternion.Euler(0f, Yaw, 0f);

		public ZoneAreaSelection(Vector3 center, float width, float depth, float yaw)
		{
			//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)
			Center = center;
			Width = Mathf.Max(0.01f, width);
			Depth = Mathf.Max(0.01f, depth);
			Yaw = NormalizeYaw(yaw);
		}

		public ZoneAreaSelection Clamp(float minSide, float maxSide)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return new ZoneAreaSelection(Center, Mathf.Clamp(Width, minSide, maxSide), Mathf.Clamp(Depth, minSide, maxSide), Yaw);
		}

		public bool Contains(Vector3 worldPosition)
		{
			//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)
			//IL_000b: 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_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)
			//IL_001d: 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)
			Vector3 val = Quaternion.Inverse(Rotation) * (worldPosition - Center);
			if (Mathf.Abs(val.x) <= Width * 0.5f)
			{
				return Mathf.Abs(val.z) <= Depth * 0.5f;
			}
			return false;
		}

		public bool IntersectsBoundary(Bounds worldBounds)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			GetLocalBounds(worldBounds, out var minX, out var maxX, out var minZ, out var maxZ);
			float num = Width * 0.5f;
			float num2 = Depth * 0.5f;
			if (!(maxX >= 0f - num) || !(minX <= num) || !(maxZ >= 0f - num2) || !(minZ <= num2))
			{
				return false;
			}
			return !(minX >= 0f - num) || !(maxX <= num) || !(minZ >= 0f - num2) || !(maxZ <= num2);
		}

		public Vector3 GetCorner(int index)
		{
			//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_0047: 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_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_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: 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_007a: 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_0066: 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)
			float num = Width * 0.5f;
			float num2 = Depth * 0.5f;
			Vector3 val = (Vector3)(index switch
			{
				0 => new Vector3(0f - num, 0f, 0f - num2), 
				1 => new Vector3(num, 0f, 0f - num2), 
				2 => new Vector3(num, 0f, num2), 
				_ => new Vector3(0f - num, 0f, num2), 
			});
			return Center + Rotation * val;
		}

		private void GetLocalBounds(Bounds worldBounds, out float minX, out float maxX, out float minZ, out float maxZ)
		{
			//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)
			//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_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0089: 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_009a: 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_00b1: 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_00cb: 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_00dc: 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_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			Quaternion val = Quaternion.Inverse(Rotation);
			Vector3 min = ((Bounds)(ref worldBounds)).min;
			Vector3 max = ((Bounds)(ref worldBounds)).max;
			minX = (minZ = float.PositiveInfinity);
			maxX = (maxZ = float.NegativeInfinity);
			Encapsulate(val * (new Vector3(min.x, 0f, min.z) - Center), ref minX, ref maxX, ref minZ, ref maxZ);
			Encapsulate(val * (new Vector3(min.x, 0f, max.z) - Center), ref minX, ref maxX, ref minZ, ref maxZ);
			Encapsulate(val * (new Vector3(max.x, 0f, min.z) - Center), ref minX, ref maxX, ref minZ, ref maxZ);
			Encapsulate(val * (new Vector3(max.x, 0f, max.z) - Center), ref minX, ref maxX, ref minZ, ref maxZ);
		}

		private static void Encapsulate(Vector3 local, ref float minX, ref float maxX, ref float minZ, ref float maxZ)
		{
			//IL_0003: 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_0021: 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)
			minX = Mathf.Min(minX, local.x);
			maxX = Mathf.Max(maxX, local.x);
			minZ = Mathf.Min(minZ, local.z);
			maxZ = Mathf.Max(maxZ, local.z);
		}

		public static float NormalizeYaw(float yaw)
		{
			yaw %= 360f;
			if (!(yaw < 0f))
			{
				return yaw;
			}
			return yaw + 360f;
		}
	}
	internal static class ZoneAreaToolShared
	{
		private const float LineHeight = 0.25f;

		private const int MinEdgeSegments = 4;

		private const int MaxEdgeSegments = 64;

		public static ZoneAreaSelection BuildArea(Vector3 center, ref float width, ref float depth, float yaw, float defaultWidth, float defaultDepth, float minSide, float maxSide)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			width = Mathf.Clamp((width <= 0f) ? defaultWidth : width, minSide, maxSide);
			depth = Mathf.Clamp((depth <= 0f) ? defaultDepth : depth, minSide, maxSide);
			return new ZoneAreaSelection(center, width, depth, yaw).Clamp(minSide, maxSide);
		}

		public static void ResizeUniform(ref float width, ref float depth, float delta, float minSide, float maxSide)
		{
			float num = Mathf.Max(minSide, Mathf.Max(width, depth));
			float num2 = Mathf.Clamp(num + delta, minSide, maxSide) / num;
			width = Mathf.Clamp(width * num2, minSide, maxSide);
			depth = Mathf.Clamp(depth * num2, minSide, maxSide);
		}

		public static void ResizeDepth(ref float depth, float delta, float minSide, float maxSide)
		{
			depth = Mathf.Clamp(depth + delta, minSide, maxSide);
		}

		public static void ResizeWidth(ref float width, float delta, float minSide, float maxSide)
		{
			width = Mathf.Clamp(width + delta, minSide, maxSide);
		}

		public static void DrawGroundRectangle(LineRenderer line, ZoneAreaSelection area, Vector3 center, float heightOffset, Color color)
		{
			//IL_0008: 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_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_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00c4: 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_00ea: 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_0062: 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_006f: 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_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			((Renderer)line).enabled = true;
			line.startColor = color;
			line.endColor = color;
			int num = Mathf.Clamp(Mathf.CeilToInt(area.MaxSide / 4f), 4, 64);
			line.positionCount = num * 4 + 1;
			int num2 = 0;
			for (int i = 0; i < 4; i++)
			{
				Vector3 corner = area.GetCorner(i);
				Vector3 corner2 = area.GetCorner((i + 1) % 4);
				for (int j = 0; j < num; j++)
				{
					Vector3 val = Vector3.Lerp(corner, corner2, (float)j / (float)num);
					val.y = ZoneToolAim.SampleGroundY(val.x, val.z, center.y) + 0.25f + heightOffset;
					line.SetPosition(num2++, val);
				}
			}
			Vector3 corner3 = area.GetCorner(0);
			corner3.y = ZoneToolAim.SampleGroundY(corner3.x, corner3.z, center.y) + 0.25f + heightOffset;
			line.SetPosition(num2, corner3);
		}

		public static LineRenderer CreateLineRenderer(Transform parent, string objectName, float width, Color color, Material? material)
		{
			//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)
			//IL_0052: 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)
			GameObject val = new GameObject(objectName);
			val.transform.SetParent(parent, false);
			LineRenderer obj = val.AddComponent<LineRenderer>();
			obj.useWorldSpace = true;
			obj.startWidth = width;
			obj.endWidth = width;
			obj.numCornerVertices = 2;
			obj.numCapVertices = 2;
			((Renderer)obj).shadowCastingMode = (ShadowCastingMode)0;
			((Renderer)obj).receiveShadows = false;
			((Renderer)obj).material = material;
			obj.startColor = color;
			obj.endColor = color;
			return obj;
		}

		public static Material? CreateLineMaterial()
		{
			//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_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			Shader val = Shader.Find("Sprites/Default") ?? Shader.Find("Unlit/Color");
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			return new Material(val)
			{
				color = Color.white
			};
		}

		public static Vector3 GetAdjustedAimPoint(Vector3 aimPoint, float yaw, Vector3 horizontalOffset, float heightOffset)
		{
			//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_0004: 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)
			return aimPoint + ZonePlacementOffset.ToWorldOffset(yaw, horizontalOffset, heightOffset);
		}

		public static string FormatSize(float width, float depth)
		{
			return $"{Mathf.RoundToInt(width)}x{Mathf.RoundToInt(depth)}m";
		}

		public static string FormatScaleInput()
		{
			if (!string.IsNullOrWhiteSpace(PlacementControlConfig.AreaUniformScaleInputLabel))
			{
				return PlacementControlConfig.AreaUniformScaleInputLabel;
			}
			return HomesteadLocalization.Text("hs_common_unbound");
		}

		public static string FormatDepthInput()
		{
			if (!string.IsNullOrWhiteSpace(BlueprintConfig.AreaToolDepthInputLabel))
			{
				return BlueprintConfig.AreaToolDepthInputLabel;
			}
			return HomesteadLocalization.Text("hs_common_unbound");
		}

		public static string FormatWidthInput()
		{
			if (!string.IsNullOrWhiteSpace(BlueprintConfig.AreaToolWidthInputLabel))
			{
				return BlueprintConfig.AreaToolWidthInputLabel;
			}
			return HomesteadLocalization.Text("hs_common_unbound");
		}

		public static float RoundOffset(float value)
		{
			return Mathf.Round(value * 1000f) / 1000f;
		}

		public static bool TryGetAimPoint(Player player, float maxSelectableSide, out Vector3 point)
		{
			return ZoneToolAim.TryGetAimPoint(player, maxSelectableSide * 2f, out point);
		}

		public static bool IsHoldingBuildTool(Player player)
		{
			return (Object)(object)((Humanoid)player).GetRightItem()?.m_shared?.m_buildPieces != (Object)null;
		}

		public static bool ShouldBlockInput()
		{
			if (Hud.IsPieceSelectionVisible() || Console.IsVisible() || TextInput.IsVisible() || Menu.IsVisible() || InventoryGui.IsVisible() || Minimap.IsOpen())
			{
				return true;
			}
			if ((Object)(object)Chat.instance != (Object)null)
			{
				return Chat.instance.HasFocus();
			}
			return false;
		}
	}
	internal sealed class ZoneAreaToolStatusHud : MonoBehaviour
	{
		private static ZoneAreaToolStatusHud? _instance;

		private static bool _missingFontLogged;

		private CanvasGroup? _canvasGroup;

		private TextMeshProUGUI? _text;

		private RectTransform? _rectTransform;

		private string _areaLine = "";

		private string _placementLine = "";

		private string _dvergrLine = "";

		private string _buildCameraLine = "";

		private string _pickupLine = "";

		private string _lastAreaLine = "";

		private string _lastPlacementLine = "";

		private string _lastDvergrLine = "";

		private float _areaHideAfter = float.MinValue;

		private float _placementHideAfter = float.MinValue;

		private float _dvergrHideAfter = float.MinValue;

		private float _buildCameraHideAfter = float.MinValue;

		private float _pickupHideAfter = float.MinValue;

		public static void Show(string title, string size, float yaw, Vector3 horizontalOffset, float heightOffset)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			ShowPlacementLine(horizontalOffset, heightOffset, yaw, FormatAreaSize(size));
		}

		public static void ShowBlueprint(string title, float yaw, Vector3 horizontalOffset, float heightOffset)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			ShowPlacementLine(horizontalOffset, heightOffset, yaw);
		}

		public static void ShowOffset(string title, Vector3 horizontalOffset, float heightOffset, float xAxisRotation = 0f, float zAxisRotation = 0f)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			float degree = ((Mathf.Abs(xAxisRotation) >= 0.001f) ? xAxisRotation : zAxisRotation);
			ShowPlacementLine(horizontalOffset, heightOffset, degree);
		}

		public static void ShowDefaultPlacement(Vector3 horizontalOffset, float heightOffset, float yaw, float xAxisRotation, float zAxisRotation, bool keepVisible)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Hud.instance == (Object)null))
			{
				EnsureInstance();
				_instance?.SetAreaLine("", keepVisible: false);
				_instance?.SetPlacementLine(FormatDefaultPlacementLine(horizontalOffset, heightOffset, yaw, xAxisRotation, zAxisRotation), 1f, keepVisible);
			}
		}

		public static void ShowDvergrCirclet(bool lightOn, float intensityMultiplier, float rangeMultiplier)
		{
			if (!((Object)(object)Hud.instance == (Object)null))
			{
				EnsureInstance();
				_instance?.SetDvergrLine(HomesteadLocalization.Format("hs_dvergr_hud", lightOn ? HomesteadLocalization.Text("hs_common_on") : HomesteadLocalization.Text("hs_common_off"), rangeMultiplier * 100f, intensityMultiplier * 100f), 1f);
			}
		}

		public static void ShowCameraPickupBlocked(string message)
		{
			if (!((Object)(object)Hud.instance == (Object)null))
			{
				EnsureInstance();
				_instance?.SetPickupLine(message, 0.35f);
			}
		}

		public static void ShowBuildCameraDistance(float currentDistance, float maxDistance, string detail)
		{
			if (!((Object)(object)Hud.instance == (Object)null))
			{
				EnsureInstance();
				string text = (string.IsNullOrWhiteSpace(detail) ? "" : (" = " + detail));
				_instance?.SetBuildCameraLine(HomesteadLocalization.Format("hs_build_camera_distance_hud", FormatMeters(currentDistance), FormatMeters(maxDistance), text));
			}
		}

		public static void HideBuildCameraDistance()
		{
			if (!((Object)(object)_instance == (Object)null))
			{
				_instance._buildCameraLine = "";
				_instance._buildCameraHideAfter = float.MinValue;
				_instance.RefreshText();
			}
		}

		public static void Hide()
		{
			ClearPlacementLine(force: true);
		}

		public static void HideDefaultPlacement()
		{
			ClearPlacementLine(force: false);
		}

		private static void ClearPlacementLine(bool force)
		{
			if (((!ZoneBlueprintSaveTool.IsActive && !ZoneAreaDismantleTool.IsActive && !ZoneBlueprintPlacementTool.IsActive) || force) && !((Object)(object)_instance == (Object)null))
			{
				_instance._placementLine = "";
				_instance._areaLine = "";
				_instance._lastPlacementLine = "";
				_instance._lastAreaLine = "";
				_instance._placementHideAfter = float.MinValue;
				_instance._areaHideAfter = float.MinValue;
				_instance.RefreshText();
			}
		}

		private static void ShowPlacementLine(Vector3 horizontalOffset, float heightOffset, float degree, string areaSize = "")
		{
			//IL_001b: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Hud.instance == (Object)null))
			{
				bool flag = !string.IsNullOrWhiteSpace(areaSize);
				bool keepVisible = flag || HasNonZeroPlacementValue(horizontalOffset, heightOffset, degree);
				EnsureInstance();
				_instance?.SetAreaLine(flag ? areaSize : "", keepVisible);
				_instance?.SetPlacementLine("X " + Format(horizontalOffset.x) + " | Y " + Format(heightOffset) + " | Z " + Format(horizontalOffset.z) + " | θ " + FormatDegree(degree), 1f, keepVisible);
			}
		}

		private static void EnsureInstance()
		{
			if ((Object)(object)Hud.instance == (Object)null)
			{
				return;
			}
			if ((Object)(object)_instance != (Object)null && Object.op_Implicit((Object)(object)_instance))
			{
				_instance.EnsureElements();
				return;
			}
			_instance = ((Component)Hud.instance).GetComponent<ZoneAreaToolStatusHud>();
			if ((Object)(object)_instance == (Object)null)
			{
				_instance = ((Component)Hud.instance).gameObject.AddComponent<ZoneAreaToolStatusHud>();
			}
			_instance.EnsureElements();
		}

		private void Update()
		{
			bool flag = false;
			if (!string.IsNullOrEmpty(_areaLine) && Time.unscaledTime > _areaHideAfter)
			{
				_areaLine = "";
				flag = true;
			}
			if (!string.IsNullOrEmpty(_placementLine) && Time.unscaledTime > _placementHideAfter)
			{
				_placementLine = "";
				flag = true;
			}
			if (!string.IsNullOrEmpty(_dvergrLine) && Time.unscaledTime > _dvergrHideAfter)
			{
				_dvergrLine = "";
				flag = true;
			}
			if (!string.IsNullOrEmpty(_buildCameraLine) && Time.unscaledTime > _buildCameraHideAfter)
			{
				_buildCameraLine = "";
				flag = true;
			}
			if (!string.IsNullOrEmpty(_pickupLine) && Time.unscaledTime > _pickupHideAfter)
			{
				_pickupLine = "";
				flag = true;
			}
			if (flag)
			{
				RefreshText();
			}
			ApplyLayout();
		}

		private void SetAreaLine(string line, bool keepVisible)
		{
			EnsureElements();
			if (!CanShow())
			{
				return;
			}
			if (string.IsNullOrWhiteSpace(line))
			{
				if (!string.IsNullOrEmpty(_areaLine) || !string.IsNullOrEmpty(_lastAreaLine))
				{
					_areaLine = "";
					_lastAreaLine = "";
					_areaHideAfter = float.MinValue;
					RefreshText();
				}
			}
			else if (!string.Equals(_lastAreaLine, line, StringComparison.Ordinal))
			{
				_lastAreaLine = line;
				_areaLine = line;
				_areaHideAfter = (keepVisible ? float.PositiveInfinity : (Time.unscaledTime + 1f));
				RefreshText();
			}
			else if (keepVisible && !float.IsPositiveInfinity(_areaHideAfter))
			{
				_areaLine = line;
				_areaHideAfter = float.PositiveInfinity;
				RefreshText();
			}
		}

		private void SetPlacementLine(string line, float visibleSeconds, bool keepVisible)
		{
			EnsureElements();
			if (CanShow())
			{
				if (!string.Equals(_lastPlacementLine, line, StringComparison.Ordinal))
				{
					_lastPlacementLine = line;
					_placementLine = line;
					_placementHideAfter = (keepVisible ? float.PositiveInfinity : (Time.unscaledTime + visibleSeconds));
					RefreshText();
				}
				else if (keepVisible && !float.IsPositiveInfinity(_placementHideAfter))
				{
					_placementLine = line;
					_placementHideAfter = float.PositiveInfinity;
					RefreshText();
				}
			}
		}

		private void SetDvergrLine(string line, float visibleSeconds)
		{
			EnsureElements();
			if (CanShow())
			{
				if (!string.Equals(_lastDvergrLine, line, StringComparison.Ordinal))
				{
					_lastDvergrLine = line;
					_dvergrLine = line;
					_dvergrHideAfter = Time.unscaledTime + visibleSeconds;
					RefreshText();
				}
				else if (Time.unscaledTime <= _dvergrHideAfter)
				{
					RefreshText();
				}
			}
		}

		private void SetPickupLine(string line, float visibleSeconds)
		{
			EnsureElements();
			if (CanShow())
			{
				_pickupLine = line;
				_pickupHideAfter = Time.unscaledTime + visibleSeconds;
				RefreshText();
			}
		}

		private void SetBuildCameraLine(string line)
		{
			EnsureElements();
			if (CanShow())
			{
				_buildCameraLine = line;
				_buildCameraHideAfter = float.PositiveInfinity;
				RefreshText();
			}
		}

		private bool CanShow()
		{
			if ((Object)(object)_text != (Object)null && (Object)(object)_canvasGroup != (Object)null)
			{
				return (Object)(object)_rectTransform != (Object)null;
			}
			return false;
		}

		private void RefreshText()
		{
			if (CanShow())
			{
				PruneExpiredLines();
				string[] source = new string[5] { _areaLine, _placementLine, _dvergrLine, _buildCameraLine, _pickupLine };
				((TMP_Text)_text).text = string.Join("\n", source.Where((string line) => !string.IsNullOrEmpty(line)));
				_canvasGroup.alpha = (string.IsNullOrEmpty(((TMP_Text)_text).text) ? 0f : 1f);
				((TMP_Text)_text).transform.SetAsLastSibling();
				ApplyLayout();
			}
		}

		private void EnsureElements()
		{
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Expected O, but got Unknown
			//IL_00bc: 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_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Hud.instance == (Object)null)
			{
				return;
			}
			TextMeshProUGUI val = FindHudTextTemplate();
			if ((Object)(object)((val != null) ? ((TMP_Text)val).font : null) == (Object)null)
			{
				LogMissingFontOnce();
				return;
			}
			if ((Object)(object)_text == (Object)null || (Object)(object)_canvasGroup == (Object)null || (Object)(object)_rectTransform == (Object)null)
			{
				_text = Object.Instantiate<TextMeshProUGUI>(val, ((Component)Hud.instance).transform, false);
				GameObject gameObject = ((Component)_text).gameObject;
				((Object)gameObject).name = "HomesteadUnifiedStatusHud";
				gameObject.SetActive(true);
				gameObject.transform.SetAsLastSibling();
				_rectTransform = (RectTransform)gameObject.transform;
				_rectTransform.anchorMin = new Vector2(0f, 1f);
				_rectTransform.anchorMax = new Vector2(0f, 1f);
				_rectTransform.pivot = new Vector2(0f, 1f);
				_canvasGroup = gameObject.GetComponent<CanvasGroup>();
				if ((Object)(object)_canvasGroup == (Object)null)
				{
					_canvasGroup = gameObject.AddComponent<CanvasGroup>();
				}
				_canvasGroup.alpha = 0f;
				((Graphic)_text).color = new Color(1f, 0.86f, 0.45f, 1f);
				((TMP_Text)_text).alignment = (TextAlignmentOptions)513;
				((TMP_Text)_text).enableAutoSizing = false;
				((TMP_Text)_text).textWrappingMode = (TextWrappingModes)0;
				((TMP_Text)_text).overflowMode = (TextOverflowModes)0;
				((TMP_Text)_text).margin = Vector4.zero;
				((Graphic)_text).raycastTarget = false;
				((TMP_Text)_text).text = string.Empty;
			}
			if (!((Object)(object)_text == (Object)null))
			{
				((TMP_Text)_text).font = ((TMP_Text)val).font;
				if ((Object)(object)((TMP_Text)val).fontSharedMaterial != (Object)null)
				{
					((TMP_Text)_text).fontSharedMaterial = ((TMP_Text)val).fontSharedMaterial;
				}
				ApplyLayout();
			}
		}

		private void ApplyLayout()
		{
			//IL_0023: 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)
			if (!((Object)(object)_rectTransform == (Object)null) && !((Object)(object)_text == (Object)null))
			{
				_rectTransform.anchoredPosition = ClientConfig.StatusHudPosition;
				((TMP_Text)_text).fontSize = ClientConfig.StatusHudFontSize;
				_rectTransform.sizeDelta = CalculateHudSize(((TMP_Text)_text).fontSize);
			}
		}

		private static TextMeshProUGUI? FindHudTextTemplate()
		{
			TMP_Text obj = Hud.instance?.m_buildSelection;
			TextMeshProUGUI val = (TextMeshProUGUI)(object)((obj is TextMeshProUGUI) ? obj : null);
			if ((Object)(object)((val != null) ? ((TMP_Text)val).font : null) != (Object)null)
			{
				return val;
			}
			Hud instance = Hud.instance;
			if (instance == null)
			{
				return null;
			}
			return ((IEnumerable<TextMeshProUGUI>)((Component)instance).GetComponentsInChildren<TextMeshProUGUI>(true)).FirstOrDefault((Func<TextMeshProUGUI, bool>)((TextMeshProUGUI text) => (Object)(object)text != (Object)null && (Object)(object)((TMP_Text)text).font != (Object)null));
		}

		private static void LogMissingFontOnce()
		{
			if (!_missingFontLogged)
			{
				_missingFontLogged = true;
				HomesteadPlugin.HomesteadLogger.LogWarning((object)"Homestead status HUD could not find a TextMeshPro font asset.");
			}
		}

		private static Vector2 CalculateHudSize(float fontSize)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			float num = fontSize * 5f * 1.45f + 12f;
			return new Vector2(Mathf.Clamp(fontSize * 34f, 220f, 1800f), Mathf.Clamp(num, 40f, 420f));
		}

		private static string Format(float value)
		{
			return value.ToString("+0.##;-0.##;0", CultureInfo.InvariantCulture);
		}

		private static string FormatDegree(float value)
		{
			return Mathf.RoundToInt(value).ToString(CultureInfo.InvariantCulture);
		}

		private static string FormatMeters(float value)
		{
			return $"{Mathf.RoundToInt(value)}m";
		}

		private static string FormatDefaultPlacementLine(Vector3 horizontalOffset, float heightOffset, float yaw, float xAxisRotation, float zAxisRotation)
		{
			//IL_0010: 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)
			string text = "X " + Format(horizontalOffset.x) + " | Y " + Format(heightOffset) + " | Z " + Format(horizontalOffset.z) + " | θ " + FormatDegree(yaw);
			if (Mathf.Abs(xAxisRotation) >= 0.001f)
			{
				text = text + " | RX " + FormatDegree(xAxisRotation);
			}
			if (Mathf.Abs(zAxisRotation) >= 0.001f)
			{
				text = text + " | RZ " + FormatDegree(zAxisRotation);
			}
			return text;
		}

		private void PruneExpiredLines()
		{
			float unscaledTime = Time.unscaledTime;
			if (!string.IsNullOrEmpty(_areaLine) && unscaledTime > _areaHideAfter)
			{
				_areaLine = "";
			}
			if (!string.IsNullOrEmpty(_placementLine) && unscaledTime > _placementHideAfter)
			{
				_placementLine = "";
			}
			if (!string.IsNullOrEmpty(_dvergrLine) && unscaledTime > _dvergrHideAfter)
			{
				_dvergrLine = "";
			}
			if (!string.IsNullOrEmpty(_buildCameraLine) && unscaledTime > _buildCameraHideAfter)
			{
				_buildCameraLine = "";
			}
			if (!string.IsNullOrEmpty(_pickupLine) && unscaledTime > _pickupHideAfter)
			{
				_pickupLine = "";
			}
		}

		private static bool HasNonZeroPlacementValue(Vector3 horizontalOffset, float heightOffset, float degree)
		{
			//IL_0000: 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)
			if (!(Mathf.Abs(horizontalOffset.x) > 0.001f) && !(Mathf.Abs(heightOffset) > 0.001f) && !(Mathf.Abs(horizontalOffset.z) > 0.001f))
			{
				return Mathf.Abs(degree) > 0.001f;
			}
			return true;
		}

		private static string FormatAreaSize(string size)
		{
			string text = (size ?? "").Trim();
			if (text.EndsWith("m", StringComparison.OrdinalIgnoreCase))
			{
				string[] array = text.Substring(0, text.Length - 1).Split(new char[1] { 'x' });
				if (array.Length == 2 && !string.IsNullOrWhiteSpace(array[0]) && !string.IsNullOrWhiteSpace(array[1]))
				{
					return array[0].Trim() + "m | " + array[1].Trim() + "m";
				}
			}
			return text;
		}
	}
	internal sealed class ZoneAreaTargetOverlay
	{
		private readonly struct OverlayCandidate
		{
			public ZDO Zdo { get; }

			public float BoundaryPriority { get; }

			public OverlayCandidate(ZDO zdo, float boundaryPriority)
			{
				Zdo = zdo;
				BoundaryPriority = boundaryPriority;
			}
		}

		private const int MaxHighlightedTargets = 1600;

		private const int MaxCandidateInspections = 2500;

		public const float BoundaryCandidatePadding = 24f;

		private static readonly Color IncludedBoundaryColor = new Color(1f, 0.9f, 0.12f, 1f);

		private static readonly Color ExcludedBoundaryColor = new Color(1f, 0.45f, 0.05f, 1f);

		private readonly Dictionary<ZDOID, bool> _highlighted = new Dictionary<ZDOID, bool>();

		private readonly Dictionary<ZDOID, bool> _nextHighlighted = new Dictionary<ZDOID, bool>();

		private readonly List<OverlayCandidate> _candidateBuffer = new List<OverlayCandidate>();

		public ZoneAreaTargetOverlay(Transform parent, string objectPrefix)
		{
		}

		public void Draw(IReadOnlyList<ZDO> candidates, ZoneAreaSelection selection)
		{
			//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_0049: 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_005a: 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_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: 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_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			_nextHighlighted.Clear();
			_candidateBuffer.Clear();
			float num = selection.HalfDiagonal + 24f;
			float num2 = num * num;
			for (int i = 0; i < candidates.Count; i++)
			{
				ZDO val = candidates[i];
				if (val != null && val.IsValid())
				{
					Vector3 position = val.GetPosition();
					if (!(HorizontalDistanceSqr(position, selection.Center) > num2) && TryEstimateBoundaryPriority(position, selection, out var boundaryPriority))
					{
						_candidateBuffer.Add(new OverlayCandidate(val, boundaryPriority));
					}
				}
			}
			_candidateBuffer.Sort((OverlayCandidate left, OverlayCandidate right) => left.BoundaryPriority.CompareTo(right.BoundaryPriority));
			int num3 = 0;
			int num4 = 0;
			foreach (OverlayCandidate item in _candidateBuffer)
			{
				if (num3 >= 1600 || num4 >= 2500)
				{
					break;
				}
				num4++;
				ZDO zdo = item.Zdo;
				if (TryClassifyBoundary(zdo, selection, out var included) && TryGetWearNTear(zdo, out WearNTear wearNTear))
				{
					_nextHighlighted[zdo.m_uid] = included;
					if (!_highlighted.TryGetValue(zdo.m_uid, out var value) || value != included)
					{
						ApplyTint(wearNTear, included ? IncludedBoundaryColor : ExcludedBoundaryColor);
					}
					num3++;
				}
			}
			_candidateBuffer.Clear();
			foreach (KeyValuePair<ZDOID, bool> item2 in _highlighted)
			{
				if (!_nextHighlighted.ContainsKey(item2.Key))
				{
					ResetTint(item2.Key);
				}
			}
			_highlighted.Clear();
			foreach (KeyValuePair<ZDOID, bool> item3 in _nextHighlighted)
			{
				_highlighted[item3.Key] = item3.Value;
			}
		}

		public void Clear()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			foreach (ZDOID key in _highlighted.Keys)
			{
				ResetTint(key);
			}
			_highlighted.Clear();
			_nextHighlighted.Clear();
			_candidateBuffer.Clear();
		}

		public void Destroy()
		{
			Clear();
		}

		private static bool TryGetWearNTear(ZDO zdo, out WearNTear wearNTear)
		{
			wearNTear = null;
			if (zdo == null || !zdo.IsValid() || (Object)(object)ZNetScene.instance == (Object)null)
			{
				return false;
			}
			ZNetView val = ZNetScene.instance.FindInstance(zdo);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			wearNTear = ((Component)val).GetComponent<WearNTear>();
			return (Object)(object)wearNTear != (Object)null;
		}

		public static void CollectNearbyZdos(ZoneAreaSelection selection, List<ZDO> buffer)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			buffer.Clear();
			if (ZDOMan.instance != null)
			{
				float num = (((Object)(object)ZoneSystem.instance != (Object)null) ? ZoneSystem.instance.m_zoneSize : 64f);
				int num2 = Mathf.CeilToInt((selection.HalfDiagonal + 24f) / Mathf.Max(1f, num));
				ZDOMan.instance.FindSectorObjects(ZoneSystem.GetZone(selection.Center), num2, 0, buffer, (List<ZDO>)null);
			}
		}

		private static bool TryClassifyBoundary(ZDO zdo, ZoneAreaSelection selection, out bool included)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: 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_003c: 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_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_0065: 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_006c: 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)
			included = false;
			if (zdo == null || !zdo.IsValid() || !ZoneBlueprintCommands.TryReadWearNTear(zdo, out GameObject prefab))
			{
				return false;
			}
			Vector3 position = zdo.GetPosition();
			included = selection.Contains(position);
			float num = selection.HalfDiagonal + 24f;
			if (HorizontalDistanceSqr(position, selection.Center) > num * num)
			{
				return false;
			}
			Vector3 vec = zdo.GetVec3(ZDOVars.s_scaleHash, prefab.transform.localScale);
			if (!HomesteadTerrainSupport.TryGetWearNTearBounds(prefab, position, zdo.GetRotation(), vec, out var bounds))
			{
				return false;
			}
			return selection.IntersectsBoundary(bounds);
		}

		private static void ApplyTint(WearNTear wearNTear, Color color)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)MaterialMan.instance == (Object)null)
			{
				wearNTear.Highlight();
				return;
			}
			GameObject gameObject = ((Component)wearNTear).gameObject;
			MaterialMan.instance.SetValue<Color>(gameObject, ShaderProps._Color, color);
			MaterialMan.instance.SetValue<Color>(gameObject, ShaderProps._EmissionColor, color * 0.35f);
		}

		private static void ResetTint(WearNTear wearNTear)
		{
			if ((Object)(object)MaterialMan.instance == (Object)null)
			{
				wearNTear.ResetHighlight();
				return;
			}
			GameObject gameObject = ((Component)wearNTear).gameObject;
			MaterialMan.instance.ResetValue(gameObject, ShaderProps._Color);
			MaterialMan.instance.ResetValue(gameObject, ShaderProps._EmissionColor);
		}

		private static void ResetTint(ZDOID id)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = (((Object)(object)ZNetScene.instance != (Object)null) ? ZNetScene.instance.FindInstance(id) : null);
			WearNTear val2 = (((Object)(object)val != (Object)null) ? val.GetComponent<WearNTear>() : null);
			if ((Object)(object)val2 != (Object)null)
			{
				ResetTint(val2);
			}
		}

		private static float HorizontalDistanceSqr(Vector3 a, Vector3 b)
		{
			//IL_0000: 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)
			//IL_000d: 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)
			float num = a.x - b.x;
			float num2 = a.z - b.z;
			return num * num + num2 * num2;
		}

		private static bool TryEstimateBoundaryPriority(Vector3 position, ZoneAreaSelection selection, out float boundaryPriority)
		{
			//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_000c: 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_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = Quaternion.Inverse(selection.Rotation) * (position - selection.Center);
			float num = selection.Width * 0.5f;
			float num2 = selection.Depth * 0.5f;
			float num3 = Mathf.Abs(val.x);
			float num4 = Mathf.Abs(val.z);
			float num5 = Mathf.Abs(num3 - num);
			float num6 = Mathf.Abs(num4 - num2);
			float num7 = Mathf.Max(num3 - num, 0f);
			float num8 = Mathf.Max(num4 - num2, 0f);
			float num9 = Mathf.Min(num - num3, num2 - num4);
			boundaryPriority = Mathf.Min(num5, num6);
			if (num7 <= 24f && num8 <= 24f)
			{
				return num9 <= 24f;
			}
			return false;
		}
	}
	[HarmonyPatch]
	internal static class ZoneBuildKeyHints
	{
		private sealed class HintWidgets
		{
			public TextMeshProUGUI? Label;

			public LayoutElement? Layout;

			public Transform? Key0Root;

			public Transform? Key1Root;

			public TextMeshProUGUI? Key0Text;

			public TextMeshProUGUI? Key1Text;

			public bool LastVisible;

			public string LastLabel = "";

			public string LastKey0 = "";

			public string LastKey1 = "";

			public float LastPreferredWidth;
		}

		private const string TemplatePath = "BuildHints/Keyboard/AltPlace";

		private const string FallbackTemplatePath = "BuildHints/Keyboard/Snap";

		private const float BuildCameraConditionRefreshInterval = 0.35f;

		private static GameObject? _offsetHint;

		private static GameObject? _gridHint;

		private static GameObject? _toolHint;

		private static GameObject? _buildCameraHint;

		private static readonly Dictionary<int, HintWidgets> HintWidgetCache = new Dictionary<int, HintWidgets>();

		private static Player? _cachedBuildCameraConditionPlayer;

		private static float _nextBuildCameraConditionRefresh;

		private static string _cachedBuildCameraCondition = "";

		[HarmonyPostfix]
		[HarmonyPatch(typeof(KeyHints), "Awake")]
		private static void KeyHintsAwakePostfix(KeyHints __instance)
		{
			EnsureHints(__instance);
			UpdateHints(__instance);
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(KeyHints), "UpdateHints")]
		private static void KeyHintsUpdateHintsPostfix(KeyHints __instance)
		{
			UpdateHints(__instance);
		}

		private static void EnsureHints(KeyHints keyHints)
		{
			if (Object.op_Implicit((Object)(object)keyHints) && !Object.op_Implicit((Object)(object)_offsetHint))
			{
				Transform val = ((Component)keyHints).transform.Find("BuildHints/Keyboard/AltPlace") ?? ((Component)keyHints).transform.Find("BuildHints/Keyboard/Snap");
				if ((Object)(object)val == (Object)null)
				{
					HomesteadPlugin.HomesteadLogger.LogDebug((object)"Homestead key hints: build hint template was not found.");
					return;
				}
				Transform parent = val.parent;
				_offsetHint = CreateHint(val, parent, "HomesteadOffsetHint", 0);
				_gridHint = CreateHint(val, parent, "HomesteadGridHint", 1);
				_toolHint = CreateHint(val, parent, "HomesteadToolHint", 2);
				_buildCameraHint = CreateHint(val, parent, "HomesteadBuildCameraHint", 3);
				HintWidgetCache.Clear();
			}
		}

		private static GameObject CreateHint(Transform template, Transform parent, string name, int siblingIndex)
		{
			GameObject obj = Object.Instantiate<GameObject>(((Component)template).gameObject, parent);
			((Object)obj).name = name;
			obj.transform.SetSiblingIndex(Mathf.Clamp(siblingIndex, 0, parent.childCount - 1));
			EnsureKeyCount(obj, 2);
			return obj;
		}

		private static void UpdateHints(KeyHints keyHints)
		{
			//IL_00e5: 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_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: 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_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: 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_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Invalid comparison between Unknown and I4
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			EnsureHints(keyHints);
			if ((Object)(object)_offsetHint == (Object)null || (Object)(object)_gridHint == (Object)null || (Object)(object)_toolHint == (Object)null || (Object)(object)_buildCameraHint == (Object)null)
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			bool flag = keyHints.m_keyHintsEnabled && (Object)(object)localPlayer != (Object)null && ((Character)localPlayer).InPlaceMode() && !ZInput.IsGamepadActive();
			if (ZoneBlueprintSaveToolMenu.IsStoreToolSelected(localPlayer))
			{
				HideHomesteadHints();
				return;
			}
			bool flag2 = ZoneBlueprintSaveTool.IsActive || ZoneAreaDismantleTool.IsActive || ZoneBlueprintPlacementTool.IsActive;
			string text = "";
			if (flag && (Object)(object)localPlayer != (Object)null && ZoneBuildCamera.IsEnabled())
			{
				text = GetCachedBuildCameraConditionText(localPlayer);
			}
			GetPlacementAdjustHintKeys(out string key, out string key2, out float preferredWidth);
			SetHint(_offsetHint, flag && (PlacementControlConfig.PlacementAdjustEnabled || flag2), HomesteadLocalization.Text("hs_keyhint_adjust_offset"), key, key2, preferredWidth);
			GameObject? gridHint = _gridHint;
			KeyboardShortcut val;
			int visible;
			if (flag)
			{
				val = PlacementControlConfig.GridSnapToggleHotkey;
				if ((int)((KeyboardShortcut)(ref val)).MainKey != 0)
				{
					visible = ((!flag2) ? 1 : 0);
					goto IL_00fc;
				}
			}
			visible = 0;
			goto IL_00fc;
			IL_00fc:
			SetHint(gridHint, (byte)visible != 0, ZoneGridSnap.IsActive ? HomesteadLocalization.Text("hs_keyhint_grid_on") : HomesteadLocalization.Text("hs_keyhint_grid_off"), FormatShortcut(PlacementControlConfig.GridSnapToggleHotkey), "", 102f);
			if (ZoneBlueprintSaveTool.IsActive || ZoneAreaDismantleTool.IsActive)
			{
				string text2 = (string.IsNullOrWhiteSpace(PlacementControlConfig.AreaUniformScaleInputLabel) ? "" : ("+" + PlacementControlConfig.PlacementAdjustModifierLabel));
				val = BlueprintConfig.AreaToolDepthModifierKey;
				string text3 = (((int)((KeyboardShortcut)(ref val)).MainKey == 0) ? "" : ("+" + BlueprintConfig.AreaToolDepthModifierLabel));
				val = BlueprintConfig.AreaToolWidthModifierKey;
				string text4 = (((int)((KeyboardShortcut)(ref val)).MainKey == 0) ? "" : ("+" + BlueprintConfig.AreaToolWidthModifierLabel));
				string key3 = string.Join("/", new string[3] { text2, text3, text4 }.Where((string value) => !string.IsNullOrWhiteSpace(value)));
				SetHint(_toolHint, flag, HomesteadLocalization.Text("hs_keyhint_area_shape"), "Wheel", key3, 166f);
			}
			else if (ZoneBlueprintPlacementTool.IsActive)
			{
				SetHint(_toolHint, flag, HomesteadLocalization.Text("hs_keyhint_blueprint_place"), "Wheel", "Mouse0", 128f);
			}
			else
			{
				_toolHint.SetActive(false);
			}
			int num;
			if (ZoneBuildCamera.InBuildMode())
			{
				val = BuildCameraConfig.LookAtLockHotkey;
				num = (((int)((KeyboardShortcut)(ref val)).MainKey > 0) ? 1 : 0);
			}
			else
			{
				num = 0;
			}
			bool flag3 = (byte)num != 0;
			SetHint(_buildCameraHint, flag && ZoneBuildCamera.IsEnabled(), flag3 ? HomesteadLocalization.Text("hs_keyhint_build_camera_lock") : HomesteadLocalization.Format("hs_keyhint_build_camera", text), FormatShortcut(BuildCameraConfig.ToggleHotkey), flag3 ? FormatShortcut(BuildCameraConfig.LookAtLockHotkey) : "", flag3 ? 190f : 160f);
		}

		private static void HideHomesteadHints()
		{
			SetActiveIfChanged(_offsetHint, active: false);
			SetActiveIfChanged(_gridHint, active: false);
			SetActiveIfChanged(_toolHint, active: false);
			SetActiveIfChanged(_buildCameraHint, active: false);
		}

		private static void SetHint(GameObject hint, bool visible, string label, string key0, string key1, float preferredTextWidth)
		{
			HintWidgets hintWidgets = GetHintWidgets(hint);
			SetActiveIfChanged(hint, visible);
			hintWidgets.LastVisible = visible;
			if (visible)
			{
				SetText(hintWidgets, label, preferredTextWidth);
				SetKeyText(hintWidgets.Key0Root, hintWidgets.Key0Text, key0, ref hintWidgets.LastKey0);
				SetKeyText(hintWidgets.Key1Root, hintWidgets.Key1Text, key1, ref hintWidgets.LastKey1);
			}
		}

		private static void SetText(HintWidgets widgets, string text, float preferredWidth)
		{
			TextMeshProUGUI label = widgets.Label;
			if ((Object)(object)label != (Object)null && !string.Equals(widgets.LastLabel, text, StringComparison.Ordinal))
			{
				Localization instance = Localization.instance;
				if (instance != null)
				{
					instance.RemoveTextFromCache((TMP_Text)(object)label);
				}
				((TMP_Text)label).text = text;
				widgets.LastLabel = text;
			}
			LayoutElement layout = widgets.Layout;
			if ((Object)(object)layout != (Object)null && Math.Abs(widgets.LastPreferredWidth - preferredWidth) > 0.1f)
			{
				layout.preferredWidth = preferredWidth;
				widgets.LastPreferredWidth = preferredWidth;
			}
		}

		private static void SetKeyText(Transform? keyRoot, TextMeshProUGUI? label, string text, ref string lastText)
		{
			if ((Object)(object)keyRoot == (Object)null)
			{
				return;
			}
			SetActiveIfChanged(((Component)keyRoot).gameObject, !string.IsNullOrWhiteSpace(text));
			if ((Object)(object)label != (Object)null && !string.Equals(lastText, text, StringComparison.Ordinal))
			{
				Localization instance = Localization.instance;
				if (instance != null)
				{
					instance.RemoveTextFromCache((TMP_Text)(object)label);
				}
				((TMP_Text)label).text = text;
				lastText = text;
			}
		}

		private static HintWidgets GetHintWidgets(GameObject hint)
		{
			int instanceID = ((Object)hint).GetInstanceID();
			if (HintWidgetCache.TryGetValue(instanceID, out HintWidgets value))
			{
				return value;
			}
			TextMeshProUGUI val = FindLabelText(hint);
			Transform keyRoot = GetKeyRoot(hint, 0);
			Transform keyRoot2 = GetKeyRoot(hint, 1);
			LayoutElement val2 = default(LayoutElement);
			value = new HintWidgets
			{
				Label = val,
				Layout = (((Object)(object)val != (Object)null && ((Component)val).TryGetComponent<LayoutElement>(ref val2)) ? val2 : null),
				Key0Root = keyRoot,
				Key1Root = keyRoot2,
				Key0Text = (((Object)(object)keyRoot != (Object)null) ? FindKeyText(keyRoot) : null),
				Key1Text = (((Object)(object)keyRoot2 != (Object)null) ? FindKeyText(keyRoot2) : null),
				LastVisible = hint.activeSelf,
				LastPreferredWidth = float.NaN
			};
			HintWidgetCache[instanceID] = value;
			return value;
		}

		private static void SetActiveIfChanged(GameObject? target, bool active)
		{
			if ((Object)(object)target != (Object)null && Object.op_Implicit((Object)(object)target) && target.activeSelf != active)
			{
				target.SetActive(active);
			}
		}

		private static string GetCachedBuildCameraConditionText(Player player)
		{
			if ((Object)(object)_cachedBuildCameraConditionPlayer != (Object)(object)player || Time.unscaledTime >= _nextBuildCameraConditionRefresh)
			{
				_cachedBuildCameraConditionPlayer = player;
				_cachedBuildCameraCondition = ZoneBuildCamera.GetKeyHintConditionText(player);
				_nextBuildCameraConditionRefresh = Time.unscaledTime + 0.35f;
			}
			return _cachedBuildCameraCondition;
		}

		private static Transform? GetKeyRoot(GameObject hint, int index)
		{
			List<Transform> list = FindKeyRoots(hint);
			if (index < 0 || index >= list.Count)
			{
				return null;
			}
			return list[index];
		}

		private static void EnsureKeyCount(GameObject hint, int count)
		{
			Transform keyRoot = GetKeyRoot(hint, 0);
			if ((Object)(object)keyRoot == (Object)null)
			{
				return;
			}
			for (int i = 1; i < count; i++)
			{
				if (!((Object)(object)GetKeyRoot(hint, i) != (Object)null))
				{
					((Object)Object.Instantiate<GameObject>(((Component)keyRoot).gameObject, keyRoot.parent).transform).name = $"key_bkg ({i})";
				}
			}
		}

		private static TextMeshProUGUI? FindLabelText(GameObject hint)
		{
			TextMeshProUGUI[] componentsInChildren = hint.GetComponentsInChildren<TextMeshProUGUI>(true);
			return ((IEnumerable<TextMeshProUGUI>)componentsInChildren).FirstOrDefault((Func<TextMeshProUGUI, bool>)((TextMeshProUGUI text) => !IsKeyText(((TMP_Text)text).transform))) ?? componentsInChildren.OrderByDescending((TextMeshProUGUI text) => ((TMP_Text)text).fontSize).FirstOrDefault();
		}

		private static TextMeshProUGUI? FindKeyText(Transform keyRoot)
		{
			return ((IEnumerable<TextMeshProUGUI>)((Component)keyRoot).GetComponentsInChildren<TextMeshProUGUI>(true)).FirstOrDefault((Func<TextMeshProUGUI, bool>)((TextMeshProUGUI text) => IsKeyText(((TMP_Text)text).transform))) ?? ((Component)keyRoot).GetComponentInChildren<TextMeshProUGUI>(true);
		}

		private static List<Transform> FindKeyRoots(GameObject hint)
		{
			GameObject hint2 = hint;
			List<Transform> list = (from transform in hint2.GetComponentsInChildren<Transform>(true)
				where (Object)(object)transform != (Object)(object)hint2.transform && IsKeyRoot(transform)
				orderby transform.GetSiblingIndex()
				select transform).ToList();
			if (list.Count > 0)
			{
				return list;
			}
			return (from transform in (from text in hint2.GetComponentsInChildren<TextMeshProUGUI>(true)
					where IsKeyText(((TMP_Text)text).transform)
					select ((TMP_Text)text).transform.parent ?? ((TMP_Text)text).transform).Distinct()
				orderby transform.GetSiblingIndex()
				select transform).ToList();
		}

		private static bool IsKeyRoot(Transform transform)
		{
			string name = ((Object)transform).name;
			if (name.IndexOf("key_bkg", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("keybkg", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("key background", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return name.Equals("key_bkg", StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}

		private static bool IsKeyText(Transform transform)
		{
			if (((Object)transform).name.Equals("Key", StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			Transform parent = transform.parent;
			while ((Object)(object)parent != (Object)null)
			{
				if (IsKeyRoot(parent))
				{
					return true;
				}
				parent = parent.parent;
			}
			return false;
		}

		private static string FormatShortcut(KeyboardShortcut shortcut)
		{
			string text = ((object)(KeyboardShortcut)(ref shortcut)).ToString();
			if (string.IsNullOrWhiteSpace(text))
			{
				return HomesteadLocalization.Text("hs_common_unbound");
			}
			return text.Replace(" + ", "+");
		}

		private static void GetPlacementAdjustHintKeys(out string key0, out string key1, out float preferredWidth)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			KeyboardShortcut placementAdjustModifierKey = PlacementControlConfig.PlacementAdjustModifierKey;
			if ((int)((KeyboardShortcut)(ref placementAdjustModifierKey)).MainKey == 0)
			{
				key0 = "Arrows";
				key1 = "PgUp/PgDn";
				preferredWidth = 104f;
			}
			else
			{
				key0 = PlacementControlConfig.PlacementAdjustModifierLabel;
				key1 = "+Arrows/+PgUpDn";
				preferredWidth = 128f;
			}
		}
	}
	internal static class ZoneBuildCamera
	{
		internal struct EyeOriginOverrideState
		{
			public bool Changed;

			public Vector3 OriginalEyePosition;
		}

		private struct BuildCameraView
		{
			public float Yaw;

			public float Pitch;
		}

		private struct NearbyCraftingStation
		{
			public Vector3 Position;

			public float Distance;

			public float RangeBuild;
		}

		private const string ExternalBuildCameraGuid = "Azumatt.BuildCameraCHE";

		private static readonly Dictionary<Player, bool> InBuildModeByPlayer = new Dictionary<Player, bool>();

		private static readonly Collider[] PickupOverlapBuffer = (Collider[])(object)new Collider[128];

		private static readonly Collider[] PickupHudOverlapBuffer = (Collider[])(object)new Collider[128];

		private static ManualLogSource Log = null;

		private static BuildCameraView _viewDirection;

		private static bool _externalBuildCameraWarningLogged;

		private static bool _showPickupBlockedHud;

		private static float _nextPickupHudRefreshTime;

		private static float _nextPickupCandidateScanTime;

		private static bool _cachedPickupCandidate;

		private static float _nextMessageTime;

		private static Transform? _lookAtTarget;

		private static Vector3 _lookAtTargetOffset = Vector3.zero;

		internal static void Initialize(ManualLogSource logger)
		{
			Log = logger;
		}

		internal static void Shutdown()
		{
			DisableBuildMode();
			InBuildModeByPlayer.Clear();
			_showPickupBlockedHud = false;
			ZoneBuildCameraDvergerLight.CleanupAll();
		}

		internal static void Update()
		{
			if (!(Time.time < _nextPickupHudRefreshTime))
			{
				_nextPickupHudRefreshTime = Time.time + 0.2f;
				_showPickupBlockedHud = ShouldShowPickupBlockedHud();
				if (_showPickupBlockedHud)
				{
					ZoneAreaToolStatusHud.ShowCameraPickupBlocked(FormatWithMinimumComfort(LocalizeText("hs_build_camera_pickup_blocked_hud", "Pickup blocked: Be cozy to use build camera item pickup (Comfort {0})")));
				}
			}
		}

		internal static bool IsEnabled()
		{
			if (!BuildCameraConfig.Enabled)
			{
				return false;
			}
			if (!Chainloader.PluginInfos.ContainsKey("Azumatt.BuildCameraCHE"))
			{
				return true;
			}
			if (!_externalBuildCameraWarningLogged)
			{
				_externalBuildCameraWarningLogged = true;
				Log.LogWarning((object)"Standalone BuildCameraCHE is loaded. Homestead built-in build camera is disabled to avoid duplicate camera patches.");
			}
			return false;
		}

		internal static bool IsLocalPlayer(Player player)
		{
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				return (Object)(object)player == (Object)(object)Player.m_localPlayer;
			}
			return false;
		}

		internal static bool InBuildMode()
		{
			Player localPlayer = Player.m_localPlayer;
			bool value = default(bool);
			return IsEnabled() && Object.op_Implicit((Object)(object)localPlayer) && InBuildModeByPlayer.TryGetValue(localPlayer, out value) && value;
		}

		internal static bool EnableBuildMode()
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if (!IsEnabled() || !Object.op_Implicit((Object)(object)localPlayer))
			{
				return false;
			}
			if (ShouldRestrictCameraEntry() && !MeetsComfortGate())
			{
				NotifyNeedCozyForCurrentMode();
				return false;
			}
			InBuildModeByPlayer[localPlayer] = true;
			SetViewDirectionFromRotation(((Component)((Character)localPlayer).m_eye).transform.rotation);
			ResetCameraSessionState();
			((Character)localPlayer).Message((MessageType)1, HomesteadLocalization.Text("hs_build_camera_enter"), 0, (Sprite)null);
			return true;
		}

		internal static void DisableBuildMode()
		{
			Player localPlayer = Player.m_localPlayer;
			if (Object.op_Implicit((Object)(object)localPlayer))
			{
				InBuildModeByPlayer[localPlayer] = false;
			}
			_showPickupBlockedHud = false;
			ResetCameraSessionState();
			ZoneAreaToolStatusHud.HideBuildCameraDistance();
		}

		internal static bool ToolIsEquipped(Player player)
		{
			ItemData rightItem = ((Humanoid)player).m_rightItem;
			if (rightItem != null && rightItem.m_shared != null)
			{
				return Object.op_Implicit((Object)(object)rightItem.m_shared.m_buildPieces);
			}
			return false;
		}

		internal static bool ShouldDeactivateBuildMode(Player player)
		{
			if (ToolIsEquipped(player))
			{
				if (ShouldRestrictCameraEntry())
				{
					return !MeetsComfortGate();
				}
				return false;
			}
			return true;
		}

		internal static bool BuildStationInRange(Player player)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			NearbyCraftingStation? nearestBuildStation = GetNearestBuildStation(GetBuildInteractionOrigin(player));
			if (nearestBuildStation.HasValue)
			{
				return nearestBuildStation.Value.Distance <= nearestBuildStation.Value.RangeBuild;
			}
			return false;
		}

		internal static Vector3 GetBuildInteractionOrigin(Player player)
		{
			//IL_0019: 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)
			if (!InBuildMode() || !Object.op_Implicit((Object)(object)GameCamera.instance))
			{
				return ((Component)player).transform.position;
			}
			return ((Component)GameCamera.instance).transform.position;
		}

		internal static bool TryGetBuildCameraOrigin(out Vector3 origin)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//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)
			if (InBuildMode() && Object.op_Implicit((Object)(object)GameCamera.instance))
			{
				origin = ((Component)GameCamera.instance).transform.position;
				return true;
			}
			origin = Vector3.zero;
			return false;
		}

		internal static EyeOriginOverrideState BeginEyeOriginOverride(Player player)
		{
			//IL_0040: 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)
			if (!Object.op_Implicit((Object)(object)player) || !Object.op_Implicit((Object)(object)((Character)player).m_eye) || !TryGetBuildCameraOrigin(out var origin))
			{
				return default(EyeOriginOverrideState);
			}
			EyeOriginOverrideState eyeOriginOverrideState = default(EyeOriginOverrideState);
			eyeOriginOverrideState.Changed = true;
			eyeOriginOverrideState.OriginalEyePosition = ((Character)player).m_eye.position;
			EyeOriginOverrideState result = eyeOriginOverrideState;
			((Character)player).m_eye.position = origin;
			return result;
		}

		internal static void EndEyeOriginOverride(Player player, EyeOriginOverrideState state)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			if (state.Changed && Object.op_Implicit((Object)(object)player) && Object.op_Implicit((Object)(object)((Character)player).m_eye))
			{
				((Character)player).m_eye.position = state.OriginalEyePosition;
			}
		}

		internal static string GetKeyHintConditionText(Player player)
		{
			if (!IsEnabled() || !Object.op_Implicit((Object)(object)player))
			{
				return "";
			}
			if (InBuildMode())
			{
				return HomesteadLocalization.Text("hs_build_camera_active");
			}
			if (!ToolIsEquipped(player))
			{
				return HomesteadLocalization.Text("hs_build_camera_need_tool");
			}
			if (!BuildStationInRange(player))
			{
				return HomesteadLocalization.Text("hs_build_camera_need_station");
			}
			string text = FormatComfortProgress();
			return BuildCameraConfig.RestrictionMode switch
			{
				BuildCameraRestrictionMode.CameraNeedsCoziness => MeetsComfortGate() ? HomesteadLocalization.Format("hs_build_camera_station_cozy", text) : HomesteadLocalization.Format("hs_build_camera_need_cozy", text), 
				BuildCameraRestrictionMode.CameraPickUpNeedsCoziness => HomesteadLocalization.Format("hs_build_camera_station_pickup_cozy", text), 
				_ => HomesteadLocalization.Text("hs_build_camera_station_ready"), 
			};
		}

		internal static void UpdateBuildCamera(float dt, GameCamera camera)
		{
			//IL_0028: 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_0034: 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_003a: 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_0049: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: 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_007f: 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)
			Player localPlayer = Player.m_localPlayer;
			if (!Object.op_Implicit((Object)(object)localPlayer) || IsInputBlocked(blockPieceSelection: true))
			{
				return;
			}
			UpdateLookAtLock(camera);
			if (((Character)localPlayer).TakeInput())
			{
				Vector3 untransformedMovementVelocity = GetUntransformedMovementVelocity(dt);
				Vector3 val = ((Component)camera).transform.TransformVector(untransformedMovementVelocity);
				Transform transform = ((Component)camera).transform;
				transform.position += val * dt;
				StayNearAvatar(localPlayer, camera);
				StayAboveGround(camera);
				ShowDistanceHud(localPlayer, camera);
				Quaternion val2 = UpdateBuildCameraViewDirection(dt);
				if (TryGetLookAtRotation(camera, out var rotation))
				{
					val2 = rotation;
					SetViewDirectionFromRotation(val2);
				}
				((Component)camera).transform.rotation = val2;
			}
		}

		internal static bool IsInputBlocked(bool blockPieceSelection)
		{
			if ((!Object.op_Implicit((Object)(object)Chat.instance) || !Chat.instance.HasFocus()) && !Console.IsVisible() && !TextInput.IsVisible() && !StoreGui.IsVisible() && !InventoryGui.IsVisible() && !Menu.IsVisible() && (!Object.op_Implicit((Object)(object)TextViewer.instance) || !TextViewer.instance.IsVisible()) && !Minimap.IsOpen() && !Hud.InRadial() && (!blockPieceSelection || !Hud.IsPieceSelectionVisible()) && !PlayerCustomizaton.BarberBlocksLook() && !PlayerCustomizaton.IsBarberGuiVisible() && !UnifiedPopup.IsVisible())
			{
				return ZNet.IsPasswordDialogShowing();
			}
			return true;
		}

		private static void ResetCameraSessionState()
		{
			ClearLookAtLock();
		}

		private static void UpdateLookAtLock(GameCamera camera)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: 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 (!ConfigValueHelpers.IsShortcutDown(BuildCameraConfig.LookAtLockHotkey))
			{
				return;
			}
			if (Object.op_Implicit((Object)(object)_lookAtTarget))
			{
				ClearLookAtLock();
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)1, HomesteadLocalization.Text("hs_build_camera_lock_off"), 0, (Sprite)null);
				}
				return;
			}
			int mask = LayerMask.GetMask(new string[8] { "Default", "static_solid", "terrain", "vehicle", "character", "piece", "character_net", "viewblock" });
			RaycastHit val = default(RaycastHit);
			if (Physics.Raycast(((Component)camera).transform.position, ((Component)camera).transform.forward, ref val, 10000f, mask) && Object.op_Implicit((Object)(object)((RaycastHit)(ref val)).collider))
			{
				_lookAtTarget = ((Component)((RaycastHit)(ref val)).collider).transform;
				_lookAtTargetOffset = _lookAtTarget.InverseTransformPoint(((RaycastHit)(ref val)).point);
				Player localPlayer2 = Player.m_localPlayer;
				if (localPlayer2 != null)
				{
					((Character)localPlayer2).Message((MessageType)1, HomesteadLocalization.Text("hs_build_camera_lock_on"), 0, (Sprite)null);
				}
			}
		}

		private static void ClearLookAtLock()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			_lookAtTarget = null;
			_lookAtTargetOffset = Vector3.zero;
		}

		private static bool TryGetLookAtRotation(GameCamera camera, out Quaternion rotation)
		{
			//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_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: 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_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			rotation = ((Component)camera).transform.rotation;
			if (!Object.op_Implicit((Object)(object)_lookAtTarget))
			{
				ClearLookAtLock();
				return false;
			}
			Vector3 val = _lookAtTarget.TransformPoint(_lookAtTargetOffset) - ((Component)camera).transform.position;
			if (((Vector3)(ref val)).sqrMagnitude < 0.0001f)
			{
				return false;
			}
			rotation = Quaternion.LookRotation(((Vector3)(ref val)).normalized, Vector3.up);
			return true;
		}

		internal static void AutoPickup(float dt, GameCamera camera)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: 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_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: 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_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: 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)
			Player localPlayer = Player.m_localPlayer;
			if (!Object.op_Implicit((Object)(object)localPlayer) || ((Character)localPlayer).IsTeleporting() || !Player.m_enableAutoPickup || (ShouldRestrictCameraPickup() && !MeetsComfortGate()))
			{
				return;
			}
			Vector3 val = ((Component)camera).transform.position + Vector3.up;
			int num = Physics.OverlapSphereNonAlloc(val, BuildCameraConfig.ResourcePickupRange, PickupOverlapBuffer, localPlayer.m_autoPickupMask);
			Collider[] array = PickupOverlapBuffer;
			if (num >= PickupOverlapBuffer.Length)
			{
				array = Physics.OverlapSphere(val, BuildCameraConfig.ResourcePickupRange, localPlayer.m_autoPickupMask);
				num = array.Length;
			}
			for (int i = 0; i < num; i++)
			{
				Collider val2 = array[i];
				if (!Object.op_Implicit((Object)(object)val2) || !Object.op_Implicit((Object)(object)val2.attachedRigidbody))
				{
					continue;
				}
				FloatingTerrainDummy val3 = null;
				ItemDrop component = ((Component)val2.attachedRigidbody).GetComponent<ItemDrop>();
				if ((Object)(object)component == (Object)null)
				{
					FloatingTerrainDummy component2 = ((Component)val2.attachedRigidbody).gameObject.GetComponent<FloatingTerrainDummy>();
					if (component2 != null && Object.op_Implicit((Object)(object)component2) && Object.op_Implicit((Object)(object)component2.m_parent))
					{
						val3 = component2;
						component = ((Component)component2.m_parent).gameObject.GetComponent<ItemDrop>();
					}
				}
				if (!IsPickupCandidate(localPlayer, component))
				{
					continue;
				}
				if (!component.CanPickup(true))
				{
					component.RequestOwn();
					continue;
				}
				component.Load();
				float num2 = Vector3.Distance(((Component)component).transform.position, val);
				if (num2 > BuildCameraConfig.ResourcePickupRange)
				{
					continue;
				}
				if (num2 < BuildCameraConfig.ResourcePickupRange)
				{
					((Humanoid)localPlayer).Pickup(((Component)component).gameObject, true, true);
					continue;
				}
				Vector3 val4 = Vector3.Normalize(val - ((Component)component).transform.position) * 15f * dt;
				Transform transform = ((Component)component).transform;
				transform.position += val4;
				if (Object.op_Implicit((Object)(object)val3))
				{
					Transform transform2 = ((Component)val3).transform;
					transform2.position += val4;
				}
			}
		}

		private static NearbyCraftingStation? GetNearestBuildStation(Vector3 position)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//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)
			NearbyCraftingStation? result = null;
			foreach (CraftingStation allStation in CraftingStation.m_allStations)
			{
				if (Object.op_Implicit((Object)(object)allStation))
				{
					float num = Vector3.Distance(((Component)allStation).transform.position, position);
					if (!result.HasValue || !(num >= result.Value.Distance))
					{
						NearbyCraftingStation value = default(NearbyCraftingStation);
						value.Position = ((Component)allStation).transform.position;
						value.Distance = num;
						value.RangeBuild = allStation.m_rangeBuild;
						result = value;
					}
				}
			}
			return result;
		}

		private static void StayNearAvatar(Player player, GameCamera camera)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_001f: 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_003a: 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_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)
			//IL_0042: 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_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)
			Vector3 position = ((Component)player).transform.position;
			Vector3 position2 = ((Component)camera).transform.position;
			float maxDistanceFromAvatar = GetMaxDistanceFromAvatar(player);
			float num = Vector3.Distance(position2, position);
			if (!(num <= maxDistanceFromAvatar) && !(num <= 0.001f))
			{
				Transform transform = ((Component)camera).transform;
				Vector3 val = position2 - position;
				transform.position = position + ((Vector3)(ref val)).normalized * maxDistanceFromAvatar;
			}
		}

		private static void ShowDistanceHud(Player player, GameCamera camera)
		{
			//IL_0006: 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)
			float currentDistance = Vector3.Distance(((Component)camera).transform.position, ((Component)player).transform.position);
			float maxDistanceFromAvatar = GetMaxDistanceFromAvatar(player);
			ZoneAreaToolStatusHud.ShowBuildCameraDistance(currentDistance, maxDistanceFromAvatar, GetDistanceDetail(player));
		}

		private static float GetMaxDistanceFromAvatar(Player player)
		{
			if (BuildCameraConfig.DistanceMode == BuildCameraDistanceMode.Fixed)
			{
				return BuildCameraConfig.MaxDistanceFromAvatar;
			}
			int distanceComfortLevel = GetDistanceComfortLevel(player);
			return BuildCameraConfig.BaseDistanceFromAvatar + (float)distanceComfortLevel * BuildCameraConfig.DistancePerComfortLevel;
		}

		private static string GetDistanceDetail(Player player)
		{
			if (BuildCameraConfig.DistanceMode == BuildCameraDistanceMode.Fixed)
			{
				return "Fixed " + FormatDistanceNumber(BuildCameraConfig.MaxDistanceFromAvatar);
			}
			int distanceComfortLevel = GetDistanceComfortLevel(player);
			return FormatDistanceNumber(BuildCameraConfig.BaseDistanceFromAvatar) + "+" + $"{FormatDistanceNumber(BuildCameraConfig.DistancePerComfortLevel)}*{distanceComfortLevel}(Comfort)";
		}

		private static int GetDistanceComfortLevel(Player player)
		{
			if (!Object.op_Implicit((Object)(object)player) || !IsComfortActive(player))
			{
				return 0;
			}
			return Mathf.Max(0, player.GetComfortLevel());
		}

		private static string FormatDistanceNumber(float value)
		{
			return value.ToString("0.##", CultureInfo.InvariantCulture);
		}

		private static void StayAboveGround(GameCamera camera)
		{
			//IL_0017: 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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			float num = default(float);
			if (Object.op_Implicit((Object)(object)ZoneSystem.instance) && ZoneSystem.instance.GetGroundHeight(((Component)camera).transform.position, ref num) && ((Component)camera).transform.position.y < num)
			{
				Vector3 position = ((Component)camera).transform.position;
				position.y = num;
				((Component)camera).transform.position = position;
			}
		}

		private static Quaternion UpdateBuildCameraViewDirection(float dt)
		{
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			_viewDirection.Yaw += PlayerController.m_mouseSens * Input.GetAxis("Mouse X") + ZInput.GetJoyRightStickX(true) * 110f * dt;
			float num = (PlayerController.m_invertMouse ? (-1f) : 1f);
			float num2 = _viewDirection.Pitch - (num * (PlayerController.m_mouseSens * Input.GetAxis("Mouse Y")) - ZInput.GetJoyRightStickY(true) * 110f * dt);
			_viewDirection.Pitch = Mathf.Clamp(num2, -89f, 89f);
			return Quaternion.Euler(0f, _viewDirection.Yaw, 0f) * Quaternion.Euler(_viewDirection.Pitch, 0f, 0f);
		}

		private static void SetViewDirectionFromRotation(Quaternion rotation)
		{
			//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_000d: 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)
			Vector3 eulerAngles = ((Quaternion)(ref rotation)).eulerAngles;
			_viewDirection.Yaw = eulerAngles.y;
			_viewDirection.Pitch = NormalizePitch(eulerAngles.x);
		}

		private static float NormalizePitch(float pitch)
		{
			if (pitch > 180f)
			{
				pitch -= 360f;
			}
			return Mathf.Clamp(pitch, -89f, 89f);
		}

		private static Vector3 GetUntransformedMovementVelocity(float dt)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: 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_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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: 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_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: 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_005a: 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_0060: 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_00d0: 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_00db: 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_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: 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_00dc: 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_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_00f2: 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_00f4: 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_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: 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_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: 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_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: 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_0171: 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)
			Vector3 val = Vector3.zero;
			if (ZInput.GetButton("Left"))
			{
				val -= Vector3.right;
			}
			if (ZInput.GetButton("Right"))
			{
				val += Vector3.right;
			}
			if (ZInput.GetButton("Forward"))
			{
				val += Vector3.forward;
			}
			if (ZInput.GetButton("Backward"))
			{
				val -= Vector3.forward;
			}
			Character.takeInputDelay = Mathf.Max(0f, Character.takeInputDelay - dt);
			if ((ZInput.GetButton("Jump") || ZInput.GetButton("JoyJump")) && Character.takeInputDelay <= 0f && !Hud.IsPieceSelectionVisible())
			{
				val += Vector3.up;
			}
			if (ZInput.GetButton("Crouch") || ZInput.GetButtonPressedTimer("JoyCrouch") > 0.33f)
			{
				val -= Vector3.up;
			}
			val += Vector3.right * ZInput.GetJoyLeftStickX(false);
			val += -Vector3.forward * ZInput.GetJoyLeftStickY(true);
			val += Vector3.up * ZInput.GetJoyRTrigger();
			val -= Vector3.up * ZInput.GetJoyLTrigger();
			if (((Vector3)(ref val)).sqrMagnitude > 1f)
			{
				((Vector3)(ref val)).Normalize();
			}
			Player localPlayer = Player.m_localPlayer;
			float num = (ZInput.GetButton("Run") ? ((Character)localPlayer).m_runSpeed : ((Character)localPlayer).m_walkSpeed);
			return val * (num * BuildCameraConfig.MoveSpeedMultiplier);
		}

		private static bool ShouldRestrictCameraEntry()
		{
			return BuildCameraConfig.RestrictionMode == BuildCameraRestrictionMode.CameraNeedsCoziness;
		}

		private static bool ShouldRestrictCameraPickup()
		{
			return BuildCameraConfig.RestrictionMode == BuildCameraRestrictionMode.CameraPickUpNeedsCoziness;
		}

		private static bool MeetsComfortGate()
		{
			Player localPlayer = Player.m_localPlayer;
			if (!Object.op_Implicit((Object)(object)localPlayer) || localPlayer.GetComfortLevel() < BuildCameraConfig.MinimumComfortLevel)
			{
				return false;
			}
			return IsComfortActive(localPlayer);
		}

		private static bool IsComfortActive(Player player)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			SEMan sEMan = ((Character)player).GetSEMan();
			if (sEMan == null)
			{
				return false;
			}
			if (sEMan.HaveStatusEffect(SEMan.s_statusEffectResting))
			{
				return true;
			}
			bool num = sEMan.HaveStatusEffect(SEMan.s_statusEffectCampFire);
			bool flag = player.InShelter() || ((Character)player).IsSitting();
			bool flag2 = player.IsSensed();
			bool flag3 = sEMan.HaveStatusEffect(SEMan.s_statusEffectCold) || sEMan.HaveStatusEffect(SEMan.s_statusEffectFreezing);
			bool flag4 = sEMan.HaveStatusEffect(SEMan.s_statusEffectBurning);
			bool flag5 = Object.op_Implicit((Object)(object)EffectArea.IsPointInsideArea(((Component)player).transform.position, (Type)64, 1f));
			bool flag6 = sEMan.HaveStatusEffect(SEMan.s_statusEffectWet) && !flag5;
			if (num && flag && !flag2 && !flag3 && !flag6)
			{
				return !flag4;
			}
			return false;
		}

		private static void NotifyNeedCozyForCurrentMode()
		{
			Player localPlayer = Player.m_localPlayer;
			if (Object.op_Implicit((Object)(object)localPlayer) && !(Time.time < _nextMessageTime))
			{
				_nextMessageTime = Time.time + 1.5f;
				string text = FormatWithMinimumComfort(LocalizeText("hs_build_camera_need_cozy_center", "Be cozy to use build camera (Comfort {0})"));
				((Character)localPlayer).Message((MessageType)2, text, 0, (Sprite)null);
			}
		}

		private static bool ShouldShowPickupBlockedHud()
		{
			if (ShouldRestrictCameraPickup() && InBuildMode() && !MeetsComfortGate() && Object.op_Implicit((Object)(object)GameCamera.instance))
			{
				return HasNearbyPickupCandidate();
			}
			return false;
		}

		private static bool HasNearbyPickupCandidate()
		{
			if (Time.time < _nextPickupCandidateScanTime)
			{
				return _cachedPickupCandidate;
			}
			_nextPickupCandidateScanTime = Time.time + 0.05f;
			_cachedPickupCandidate = HasNearbyPickupCandidateUncached();
			return _cachedPickupCandidate;
		}

		private static bool HasNearbyPickupCandidateUncached()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//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_0117: 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)
			Player localPlayer = Player.m_localPlayer;
			GameCamera instance = GameCamera.instance;
			if (!Object.op_Implicit((Object)(object)localPlayer) || !Object.op_Implicit((Object)(object)instance) || ((Character)localPlayer).IsTeleporting() || !Player.m_enableAutoPickup)
			{
				return false;
			}
			Vector3 val = ((Component)instance).transform.position + Vector3.up;
			float resourcePickupRange = BuildCameraConfig.ResourcePickupRange;
			int num = Physics.OverlapSphereNonAlloc(val, resourcePickupRange, PickupHudOverlapBuffer, localPlayer.m_autoPickupMask);
			Collider[] array = PickupHudOverlapBuffer;
			if (num >= PickupHudOverlapBuffer.Length)
			{
				array = Physics.OverlapSphere(val, resourcePickupRange, localPlayer.m_autoPickupMask);
				num = array.Length;
			}
			for (int i = 0; i < num; i++)
			{
				Collider val2 = array[i];
				if (!Object.op_Implicit((Object)(object)val2) || !Object.op_Implicit((Object)(object)val2.attachedRigidbody))
				{
					continue;
				}
				ItemDrop component = ((Component)val2.attachedRigidbody).GetComponent<ItemDrop>();
				if ((Object)(object)component == (Object)null)
				{
					FloatingTerrainDummy component2 = ((Component)val2.attachedRigidbody).gameObject.GetComponent<FloatingTerrainDummy>();
					if (component2 != null && Object.op_Implicit((Object)(object)component2) && Object.op_Implicit((Object)(object)component2.m_parent))
					{
						component = ((Component)component2.m_parent).gameObject.GetComponent<ItemDrop>();
					}
				}
				if (IsPickupCandidate(localPlayer, component) && Vector3.Distance(((Component)component).transform.position, val) <= resourcePickupRange)
				{
					return true;
				}
			}
			return false;
		}

		private static bool IsPickupCandidate(Player player, ItemDrop? itemDrop)
		{
			if ((Object)(object)itemDrop == (Object)null || !itemDrop.m_autoPickup || itemDrop.InTar())
			{
				return false;
			}
			ZNetView component = ((Component)itemDrop).GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || !component.IsValid())
			{
				return false;
			}
			if (((Humanoid)player).HaveUniqueKey(itemDrop.m_itemData.m_shared.m_name))
			{
				return false;
			}
			if (!itemDrop.CanPickup(true))
			{
				return true;
			}
			itemDrop.Load();
			if (((Humanoid)player).m_inventory.CanAddItem(itemDrop.m_itemData, -1))
			{
				return itemDrop.m_itemData.GetWeight(-1) + ((Humanoid)player).m_inventory.GetTotalWeight() <= player.GetMaxCarryWeight();
			}
			return false;
		}

		private static string LocalizeText(string key, string fallback)
		{
			Localization instance = Localization.instance;
			if (instance == null)
			{
				return fallback;
			}
			string text = "$" + key;
			string text2 = instance.Localize(text);
			if (!(text2 == text))
			{
				return text2;
			}
			return fallback;
		}

		private static string FormatWithMinimumComfort(string template)
		{
			try
			{
				return string.Format(template, BuildCameraConfig.MinimumComfortLevel);
			}
			catch (FormatException)
			{
				return $"{template} (Comfort {BuildCameraConfig.MinimumComfortLevel})";
			}
		}

		private static string FormatComfortProgress()
		{
			Player localPlayer = Player.m_localPlayer;
			int num = (Object.op_Implicit((Object)(object)localPlayer) ? localPlayer.GetComfortLevel() : 0);
			return $"C{num}/{BuildCameraConfig.MinimumComfortLevel}";
		}
	}
	[HarmonyPatch(typeof(SE_Demister), "UpdateStatusEffect")]
	internal static class ZoneBuildCameraDemisterPatch
	{
		private struct ForceFieldData
		{
			public float EndRange;
		}

		private const float BuildCameraDemisterRangeMultiplier = 2.5f;

		private static readonly Dictionary<GameObject, ForceFieldData> OriginalForceFields = new Dictionary<GameObject, ForceFieldData>();

		private static bool Prefix(SE_Demister __instance, float dt)
		{
			Character character = ((StatusEffect)__instance).m_character;
			Player val = (Player)(object)((character is Player) ? character : null);
			if ((Object)(object)val == (Object)null || !ZoneBuildCamera.IsLocalPlayer(val) || !ZoneBuildCamera.InBuildMode() || !BuildCameraConfig.DemisterFollowCamera)
			{
				RestoreNormalForceField(__instance);
				return true;
			}
			IncreaseForceFieldRange(__instance);
			UpdateDemisterForCamera(__instance, val, dt);
			return false;
		}

		internal static void CleanupBall(GameObject ball)
		{
			if (Object.op_Implicit((Object)(object)ball))
			{
				OriginalForceFields.Remove(ball);
			}
		}

		private static void IncreaseForceFieldRange(SE_Demister instance)
		{
			if (Object.op_Implicit((Object)(object)instance.m_ballInstance) && !OriginalForceFields.ContainsKey(instance.m_ballInstance))
			{
				ParticleSystemForceField componentInChildren = instance.m_ballInstance.GetComponentInChildren<ParticleSystemForceField>();
				if (Object.op_Implicit((Object)(object)componentInChildren))
				{
					OriginalForceFields[instance.m_ballInstance] = new ForceFieldData
					{
						EndRange = componentInChildren.endRange
					};
					componentInChildren.endRange *= 2.5f;
				}
			}
		}

		private static void RestoreNormalForceField(SE_Demister instance)
		{
			if (Object.op_Implicit((Object)(object)instance.m_ballInstance) && OriginalForceFields.TryGetValue(instance.m_ballInstance, out var value))
			{
				ParticleSystemForceField componentInChildren = instance.m_ballInstance.GetComponentInChildren<ParticleSystemForceField>();
				if (Object.op_Implicit((Object)(object)componentInChildren))
				{
					componentInChildren.endRange = value.EndRange;
				}
				OriginalForceFields.Remove(instance.m_ballInstance);
			}
		}

		private static void UpdateDemisterForCamera(SE_Demister instance, Player player, float dt)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0031: 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_005c: 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_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_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: 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_00a2: 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_00a9: 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_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: 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_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//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_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: 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_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: 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_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: 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_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: 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_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//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_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: 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_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: 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_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: 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_01cd: 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_01de: 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_01e8: Unknown result type (might be due to invalid IL or missing references)
			Vector3 cameraPosition = GetCameraPosition();
			Vector3 cameraForward = GetCameraForward();
			if (!Object.op_Implicit((Object)(object)instance.m_ballInstance))
			{
				instance.m_ballInstance = Object.Instantiate<GameObject>(instance.m_ballPrefab, cameraPosition + cameraForward * 0.5f, Quaternion.identity);
				return;
			}
			bool num = IsUnderRoof(instance);
			Vector3 val = instance.m_ballInstance.transform.position;
			Vector3 val2 = (num ? instance.m_offsetInterior : instance.m_offset);
			float num2 = (num ? instance.m_noiseDistanceInterior : instance.m_noiseDistance);
			Vector3 val3 = GetCameraRight() * val2.x + GetCameraUp() * val2.y + cameraForward * val2.z;
			Vector3 val4 = cameraPosition + val3;
			float num3 = Time.time * instance.m_noiseSpeed;
			Vector3 val5 = new Vector3(Mathf.Sin(num3 * 4f), Mathf.Sin(num3 * 2f) * instance.m_noiseDistanceYScale, Mathf.Cos(num3 * 5f)) * num2;
			Vector3 val6 = val4 + val5;
			float num4 = Vector3.Distance(val6, val);
			Vector3 val7;
			if (num4 > instance.m_maxDistance * 2f)
			{
				val = val6;
			}
			else if (num4 > instance.m_maxDistance)
			{
				val7 = val - val6;
				Vector3 normalized = ((Vector3)(ref val7)).normalized;
				val = val6 + normalized * instance.m_maxDistance;
			}
			Vector3 ballVel = instance.m_ballVel;
			val7 = val6 - val;
			instance.m_ballVel = ballVel + ((Vector3)(ref val7)).normalized * instance.m_ballAcceleration * dt;
			if (((Vector3)(ref instance.m_ballVel)).magnitude > instance.m_ballMaxSpeed)
			{
				instance.m_ballVel = ((Vector3)(ref instance.m_ballVel)).normalized * instance.m_ballMaxSpeed;
			}
			if (!num)
			{
				instance.m_ballVel += ((Character)player).GetVelocity() * instance.m_characterVelocityFactor * dt;
			}
			instance.m_ballVel -= instance.m_ballVel * instance.m_ballFriction;
			instance.m_ballInstance.transform.position = val + instance.m_ballVel * dt;
			Transform transform = instance.m_ballInstance.transform;
			transform.rotation *= Quaternion.Euler(instance.m_rotationSpeed, 0f, instance.m_rotationSpeed * 0.5321f);
		}

		private static Vector3 GetCameraPosition()
		{
			//IL_001c: 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)
			if (!Object.op_Implicit((Object)(object)GameCamera.instance))
			{
				return Vector3.zero;
			}
			return ((Component)GameCamera.instance).transform.position;
		}

		private static Vector3 GetCameraForward()
		{
			//IL_001c: 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)
			if (!Object.op_Implicit((Object)(object)GameCamera.instance))
			{
				return Vector3.forward;
			}
			return ((Component)GameCamera.instance).transform.forward;
		}

		private static Vector3 GetCameraRight()
		{
			//IL_001c: 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)
			if (!Object.op_Implicit((Object)(object)GameCamera.instance))
			{
				return Vector3.right;
			}
			return ((Component)GameCamera.instance).transform.right;
		}

		private static Vector3 GetCameraUp()
		{
			//IL_001c: 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)
			if (!Object.op_Implicit((Object)(object)GameCamera.instance))
			{
				return Vector3.up;
			}
			return ((Component)GameCamera.instance).transform.up;
		}

		private static bool IsUnderRoof(SE_Demister instance)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			RaycastHit val = default(RaycastHit);
			return Physics.Raycast(GetCameraPosition(), Vector3.up, ref val, 4f, instance.m_coverRayMask);
		}
	}
	[HarmonyPatch(typeof(SE_Demister), "RemoveEffects")]
	internal static class ZoneBuildCameraDemisterCleanupPatch
	{
		private static void Prefix(SE_Demister __instance)
		{
			ZoneBuildCameraDemisterPatch.CleanupBall(__instance.m_ballInstance);
		}
	}
	internal static class ZoneBuildCameraDvergerLight
	{
		private sealed class ProxyLightState
		{
			public Light Source;

			public int SourceVisibleCullingMask;

			public Light ProxyLight;

			public GameObject ProxyObject;
		}

		private sealed class CircletExtendedApi
		{
			public MethodInfo? GetCircletMethod;

			public MethodInfo? GetCircletDataMethod;

			public FieldInfo? CircletItemInstanceField;

			public Type? VisEquipmentCircletType;

			public Func<Humanoid, ItemData?>? GetCircletFast;

			public Func<VisEquipment, object?>? GetCircletDataFast;

			public Func<object, GameObject?>? GetCircletInstanceFast;
		}

		[HarmonyPatch(typeof(GameCamera), "UpdateCamera")]
		private static class GameCameraUpdatePatch
		{
			private static void Postfix(GameCamera __instance)
			{
				try
				{
					UpdateProxyLights(__instance);
				}
				catch (Exception ex)
				{
					if (Time.time >= _nextWarningLogTime)
					{
						_nextWarningLogTime = Time.time + 2f;
						HomesteadPlugin.HomesteadLogger.LogWarning((object)("Dvergr circlet build camera light failed: " + ex.Message));
					}
					CleanupAll();
				}
			}
		}

		[HarmonyPatch(typeof(Player), "SetLocalPlayer")]
		private static class PlayerSetLocalPlayerPatch
		{
			private static void Postfix()
			{
				CleanupAll();
			}
		}

		private const string CircletExtendedGuid = "shudnal.CircletExtended";

		private static readonly Dictionary<int, ProxyLightState> ProxyBySourceId = new Dictionary<int, ProxyLightState>();

		private static readonly BindingFlags StaticMethodFlags = BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;

		private static readonly BindingFlags InstanceFieldFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;

		private static readonly List<Light> TempLights = new List<Light>();

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

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

		private static readonly List<int> TempRemoveSourceIds = new List<int>();

		private static CircletExtendedApi? _circletExtendedApi;

		private static bool _circletExtendedApiInitialized;

		private static float _nextWarningLogTime;

		internal static void CleanupAll()
		{
			foreach (KeyValuePair<int, ProxyLightState> item in ProxyBySourceId)
			{
				RestoreSourceAndDestroyProxy(item.Value.Source, item.Value);
			}
			ProxyBySourceId.Clear();
		}

		private static void UpdateProxyLights(GameCamera camera)
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if (!BuildCameraConfig.FollowDvergrCircletLight || !Object.op_Implicit((Object)(object)localPlayer) || !Object.op_Implicit((Object)(object)camera) || !ZoneBuildCamera.InBuildMode() || !IsAnySupportedCircletEquipped(localPlayer))
			{
				CleanupAll();
				return;
			}
			if (!TryGetHelmetLights(localPlayer, TempLights) || TempLights.Count == 0)
			{
				CleanupAll();
				return;
			}
			Vector3 cameraOffset = default(Vector3);
			((Vector3)(ref cameraOffset))..ctor(0f, BuildCameraConfig.HelmetLightOffsetUp, BuildCameraConfig.HelmetLightOffsetForward);
			RemoveStaleSources(TempLights);
			AddNewSources(TempLights, ((Component)camera).transform, cameraOffset);
			UpdateExistingProxies(((Component)camera).transform, cameraOffset);
		}

		private static bool IsAnySupportedCircletEquipped(Player player)
		{
			if (ZoneDvergrCirclet.TryGetEquippedDvergrCirclet(player, out ItemData _))
			{
				return true;
			}
			return IsDvergrCircletItem(GetCircletExtendedEquippedCirclet(player));
		}

		private static bool IsDvergrCircletItem(ItemData? item)
		{
			if (item == null)
			{
				return false;
			}
			string text = (Object.op_Implicit((Object)(object)item.m_dropPrefab) ? ((Object)item.m_dropPrefab).name : string.Empty);
			if (text.Equals("HelmetDverger", StringComparison.OrdinalIgnoreCase) || text.StartsWith("HelmetDverger", StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			string text2 = item.m_shared?.m_name ?? string.Empty;
			if (text2.IndexOf("helmet_dverger", StringComparison.OrdinalIgnoreCase) < 0)
			{
				if (text2.IndexOf("dverger", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					if (text2.IndexOf("helmet", StringComparison.OrdinalIgnoreCase) < 0)
					{
						return text2.IndexOf("circlet", StringComparison.OrdinalIgnoreCase) >= 0;
					}
					return true;
				}
				return false;
			}
			return true;
		}

		private static ItemData? GetCircletExtendedEquippedCirclet(Player player)
		{
			CircletExtendedApi circletExtendedApi = GetCircletExtendedApi();
			if (circletExtendedApi == null)
			{
				return null;
			}
			if (circletExtendedApi.GetCircletFast != null)
			{
				try
				{
					return circletExtendedApi.GetCircletFast((Humanoid)(object)player);
				}
				catch
				{
				}
			}
			if (circletExtendedApi.GetCircletMethod == null)
			{
				return null;
			}
			try
			{
				object? obj2 = circletExtendedApi.GetCircletMethod.Invoke(null, new object[1] { player });
				return (ItemData?)((obj2 is ItemData) ? obj2 : null);
			}
			catch
			{
				return null;
			}
		}

		private static bool TryGetHelmetLights(Player player, List<Light> output)
		{
			output.Clear();
			VisEquipment visEquipment = ((Humanoid)player).m_visEquipment;
			if (!Object.op_Implicit((Object)(object)visEquipment))
			{
				return false;
			}
			if (Object.op_Implicit((Object)(object)visEquipment.m_helmetItemInstance))
			{
				AppendLightsFromRoot(visEquipment.m_helmetItemInstance, output);
			}
			if (ZoneDvergrCirclet.TryGetEquippedDvergrCirclet(player, out ItemData item) && item != null && AzuExtendedPlayerInventoryCompat.TryGetCustomEquipVisualRoots(visEquipment, item, TempVisualRoots))
			{
				foreach (GameObject tempVisualRoot in TempVisualRoots)
				{
					if (Object.op_Implicit((Object)(object)tempVisualRoot))
					{
						AppendLightsFromRoot(tempVisualRoot, output);
					}
				}
			}
			ZoneDvergrCirclet.TryAppendFallbackLight(output);
			if (TryGetCircletExtendedItemInstance(visEquipment, out GameObject circletItemInstance) && Object.op_Implicit((Object)(object)circletItemInstance))
			{
				AppendLightsFromRoot(circletItemInstance, output);
			}
			return output.Count > 0;
		}

		private static void AppendLightsFromRoot(GameObject root, List<Light> output)
		{
			root.GetComponentsInChildren<Light>(true, output);
			for (int num = output.Count - 1; num >= 0; num--)
			{
				if ((Object)(object)output[num] == (Object)null)
				{
					output.RemoveAt(num);
				}
			}
		}

		private static bool TryGetCircletExtendedItemInstance(VisEquipment visEquipment, out GameObject? circletItemInstance)
		{
			circletItemInstance = null;
			CircletExtendedApi circletExtendedApi = GetCircletExtendedApi();
			if (circletExtendedApi == null || (circletExtendedApi.GetCircletDataFast == null && circletExtendedApi.GetCircletDataMethod == null) || (circletExtendedApi.GetCircletInstanceFast == null && circletExtendedApi.CircletItemInstanceField == null))
			{
				return false;
			}
			try
			{
				object obj = ((circletExtendedApi.GetCircletDataFast != null) ? circletExtendedApi.GetCircletDataFast(visEquipment) : circletExtendedApi.GetCircletDataMethod?.Invoke(null, new object[1] { visEquipment }));
				if (obj == null)
				{
					return false;
				}
				GameObject val = (GameObject)((circletExtendedApi.GetCircletInstanceFast != null) ? ((object)circletExtendedApi.GetCircletInstanceFast(obj)) : ((object)/*isinst with value type is only supported in some contexts*/));
				if (Object.op_Implicit((Object)(object)val))
				{
					circletItemInstance = val;
					return true;
				}
			}
			catch
			{
			}
			return false;
		}

		private static void RemoveStaleSources(List<Light> currentSources)
		{
			TempSourceIdSet.Clear();
			foreach (Light currentSource in currentSources)
			{
				if (Object.op_Implicit((Object)(object)currentSource))
				{
					TempSourceIdSet.Add(((Object)currentSource).GetInstanceID());
				}
			}
			TempRemoveSourceIds.Clear();
			foreach (KeyValuePair<int, ProxyLightState> item in ProxyBySourceId)
			{
				if (!Object.op_Implicit((Object)(object)item.Value.Source) || !TempSourceIdSet.Contains(item.Key))
				{
					TempRemoveSourceIds.Add(item.Key);
				}
			}
			foreach (int tempRemoveSourceId in TempRemoveSourceIds)
			{
				RemoveProxyState(tempRemoveSourceId);
			}
		}

		private static void AddNewSources(List<Light> currentSources, Transform cameraTransform, Vector3 cameraOffset)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			foreach (Light currentSource in currentSources)
			{
				if (Object.op_Implicit((Object)(object)currentSource))
				{
					int instanceID = ((Object)currentSource).GetInstanceID();
					if (!ProxyBySourceId.ContainsKey(instanceID))
					{
						ProxyBySourceId[instanceID] = CreateProxyState(currentSource, cameraTransform, cameraOffset);
					}
				}
			}
		}

		private static void UpdateExistingProxies(Transform cameraTransform, Vector3 cameraOffset)
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			TempRemoveSourceIds.Clear();
			foreach (KeyValuePair<int, ProxyLightState> item in ProxyBySourceId)
			{
				ProxyLightState value = item.Value;
				Light source = value.Source;
				if (!Object.op_Implicit((Object)(object)source) || (Object)(object)value.ProxyLight == (Object)null || (Object)(object)value.ProxyObject == (Object)null)
				{
					TempRemoveSourceIds.Add(item.Key);
					continue;
				}
				CopyLightState(source, value.ProxyLight);
				SuppressSourceLight(source, value);
				value.ProxyObject.transform.position = CalculateCameraFollowPosition(cameraTransform, cameraOffset);
				value.ProxyObject.transform.rotation = cameraTransform.rotation;
				value.ProxyObject.SetActive(((Component)source).gameObject.activeInHierarchy);
			}
			foreach (int tempRemoveSourceId in TempRemoveSourceIds)
			{
				RemoveProxyState(tempRemoveSourceId);
			}
		}

		private static ProxyLightState CreateProxyState(Light source, Transform cameraTransform, Vector3 cameraOffset)
		{
			//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_001e: Expected O, but got Unknown
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Homestead_DvergrBuildCameraLight_" + ((Object)source).name)
			{
				hideFlags = (HideFlags)61
			};
			Light val2 = val.AddComponent<Light>();
			CopyLightState(source, val2);
			ProxyLightState proxyLightState = new ProxyLightState
			{
				Source = source,
				SourceVisibleCullingMask = source.cullingMask,
				ProxyLight = val2,
				ProxyObject = val
			};
			proxyLightState.ProxyObject.transform.position = CalculateCameraFollowPosition(cameraTransform, cameraOffset);
			proxyLightState.ProxyObject.transform.rotation = cameraTransform.rotation;
			SuppressSourceLight(source, proxyLightState);
			return proxyLightState;
		}

		private static void RemoveProxyState(int sourceId)
		{
			if (ProxyBySourceId.TryGetValue(sourceId, out ProxyLightState value))
			{
				RestoreSourceAndDestroyProxy(value.Source, value);
				ProxyBySourceId.Remove(sourceId);
			}
		}

		private static void RestoreSourceAndDestroyProxy(Light? source, ProxyLightState? state)
		{
			if ((Object)(object)source != (Object)null && state != null)
			{
				source.cullingMask = state.SourceVisibleCullingMask;
			}
			if ((Object)(object)state?.ProxyObject != (Object)null)
			{
				Object.Destroy((Object)(object)state.ProxyObject);
			}
		}

		private static void SuppressSourceLight(Light source, ProxyLightState state)
		{
			if (source.cullingMask != 0)
			{
				state.SourceVisibleCullingMask = source.cullingMask;
				source.cullingMask = 0;
			}
		}

		private static Vector3 CalculateCameraFollowPosition(Transform cameraTransform, Vector3 cameraOffset)
		{
			//IL_0001: 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_000c: 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)
			//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_0028: 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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: 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)
			return cameraTransform.position + cameraTransform.right * cameraOffset.x + cameraTransform.up * cameraOffset.y + cameraTransform.forward * cameraOffset.z;
		}

		private static void CopyLightState(Light src, Light dst)
		{
			//IL_0002: 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_006e: 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_0092: Unknown result type (might be due to invalid IL or missing references)
			dst.type = src.type;
			dst.color = src.color;
			dst.colorTemperature = src.colorTemperature;
			dst.useColorTemperature = src.useColorTemperature;
			dst.intensity = src.intensity;
			dst.range = src.range;
			dst.spotAngle = src.spotAngle;
			dst.cookie = src.cookie;
			dst.cookieSize = src.cookieSize;
			dst.shadows = src.shadows;
			dst.shadowStrength = src.shadowStrength;
			dst.shadowResolution = src.shadowResolution;
			dst.renderMode = src.renderMode;
			dst.cullingMask = ((src.cullingMask != 0) ? src.cullingMask : dst.cullingMask);
			((Behaviour)dst).enabled = ((Behaviour)src).enabled;
		}

		private static CircletExtendedApi? GetCircletExtendedApi()
		{
			if (_circletExtendedApiInitialized)
			{
				return _circletExtendedApi;
			}
			_circletExtendedApiInitialized = true;
			if (!Chainloader.PluginInfos.TryGetValue("shudnal.CircletExtended", out var value))
			{
				return null;
			}
			Assembly obj = ((object)value.Instance)?.GetType().Assembly;
			Type type = obj?.GetType("CircletExtended.HumanoidExtension", throwOnError: false);
			Type type2 = obj?.GetType("CircletExtended.VisEquipmentExtension", throwOnError: false);
			Type type3 = obj?.GetType("CircletExtended.VisEquipmentCirclet", throwOnError: false);
			MethodInfo methodInfo = FindStaticMethod(type, "GetCirclet", typeof(Humanoid));
			MethodInfo methodInfo2 = FindStaticMethod(type2, "GetCircletData", typeof(VisEquipment));
			FieldInfo fieldInfo = type3?.GetField("m_circletItemInstance", InstanceFieldFlags);
			_circletExtendedApi = new CircletExtendedApi
			{
				GetCircletMethod = methodInfo,
				GetCircletDataMethod = methodInfo2,
				CircletItemInstanceField = fieldInfo,
				VisEquipmentCircletType = type3,
				GetCircletFast = CreateCircletExtendedGetCircletDelegate(methodInfo),
				GetCircletDataFast = CreateCircletExtendedGetCircletDataDelegate(methodInfo2),
				GetCircletInstanceFast = CreateCircletExtendedGetCircletInstanceDelegate(type3, fieldInfo)
			};
			return _circletExtendedApi;
		}

		private static MethodInfo? FindStaticMethod(Type? type, string name, params Type[] parameterTypes)
		{
			if (type == null)
			{
				return null;
			}
			MethodInfo[] methods = type.GetMethods(StaticMethodFlags);
			foreach (MethodInfo methodInfo in methods)
			{
				if (methodInfo.Name != name)
				{
					continue;
				}
				ParameterInfo[] parameters = methodInfo.GetParameters();
				if (parameters.Length != parameterTypes.Length)
				{
					continue;
				}
				bool flag = true;
				for (int j = 0; j < parameters.Length; j++)
				{
					if (parameters[j].ParameterType != parameterTypes[j])
					{
						flag = false;
						break;
					}
				}
				if (flag)
				{
					return methodInfo;
				}
			}
			return null;
		}

		private static Func<Humanoid, ItemData?>? CreateCircletExtendedGetCircletDelegate(MethodInfo? method)
		{
			if (method == null)
			{
				return null;
			}
			try
			{
				return (Func<Humanoid, ItemData>)Delegate.CreateDelegate(typeof(Func<Humanoid, ItemData>), method);
			}
			catch
			{
				return null;
			}
		}

		private static Func<VisEquipment, object?>? CreateCircletExtendedGetCircletDataDelegate(MethodInfo? method)
		{
			if (method == null)
			{
				return null;
			}
			try
			{
				return (Func<VisEquipment, object>)Delegate.CreateDelegate(typeof(Func<VisEquipment, object>), method);
			}
			catch
			{
				return null;
			}
		}

		private static Func<object, GameObject?>? CreateCircletExtendedGetCircletInstanceDelegate(Type? circletType, FieldInfo? itemInstanceField)
		{
			if (itemInstanceField == null || circletType == null)
			{
				return null;
			}
			try
			{
				ParameterExpression parameterExpression = Expression.Parameter(typeof(object), "obj");
				return Expression.Lambda<Func<object, GameObject>>(Expression.Convert(Expression.Field(Expression.Convert(parameterExpression, circletType), itemInstanceField), typeof(GameObject)), new ParameterExpression[1] { parameterExpression }).Compile();
			}
			catch
			{
				return null;
			}
		}
	}
	[HarmonyPatch(typeof(Player), "SetLocalPlayer")]
	internal static class ZoneBuildCameraPlayerSetLocalPlayerPatch
	{
		private static void Postfix()
		{
			ZoneBuildCamera.DisableBuildMode();
			HomesteadFeatureBootstrap.OnLocalPlayerSet();
		}
	}
	[HarmonyPatch(typeof(CraftingStation), "HaveBuildStationInRange")]
	internal static class ZoneBuildCameraCraftingStationHaveBuildStationInRangePatch
	{
		private static void Prefix(ref Vector3 point)
		{
			//IL_000a: 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 (ZoneBuildCamera.TryGetBuildCameraOrigin(out var origin))
			{
				point = origin;
			}
		}
	}
	[HarmonyPatch(typeof(Player), "PieceRayTest")]
	internal static class ZoneBuildCameraPlayerPieceRayTestPatch
	{
		private static void Prefix(Player __instance, ref ZoneBuildCamera.EyeOriginOverrideState __state)
		{
			__state = ZoneBuildCamera.BeginEyeOriginOverride(__instance);
		}

		private static void Postfix(Player __instance, ZoneBuildCamera.EyeOriginOverrideState __state)
		{
			ZoneBuildCamera.EndEyeOriginOverride(__instance, __state);
		}
	}
	[HarmonyPatch(typeof(Player), "UpdateWearNTearHover")]
	internal static class ZoneBuildCameraPlayerUpdateWearNTearHoverPatch
	{
		private static void Prefix(Player __instance, ref ZoneBuildCamera.EyeOriginOverrideState __state)
		{
			__state = ZoneBuildCamera.BeginEyeOriginOverride(__instance);
		}

		private static void Postfix(Player __instance, ZoneBuildCamera.EyeOriginOverrideState __state)
		{
			ZoneBuildCamera.EndEyeOriginOverride(__instance, __state);
		}
	}
	[HarmonyPatch(typeof(Player), "CopyPiece")]
	internal static class ZoneBuildCameraPlayerCopyPiecePatch
	{
		private static void Prefix(Player __instance, ref ZoneBuildCamera.EyeOriginOverrideState __state)
		{
			__state = ZoneBuildCamera.BeginEyeOriginOverride(__instance);
		}

		private static void Postfix(Player __instance, ZoneBuildCamera.EyeOriginOverrideState __state)
		{
			ZoneBuildCamera.EndEyeOriginOverride(__instance, __state);
		}
	}
	[HarmonyPatch(typeof(Player), "RemovePiece")]
	internal static class ZoneBuildCameraPlayerRemovePiecePatch
	{
		private static void Prefix(Player __instance, ref ZoneBuildCamera.EyeOriginOverrideState __state)
		{
			__state = ZoneBuildCamera.BeginEyeOriginOverride(__instance);
		}

		private static void Postfix(Player __instance, ZoneBuildCamera.EyeOriginOverrideState __state)
		{
			ZoneBuildCamera.EndEyeOriginOverride(__instance, __state);
		}
	}
	[HarmonyPatch(typeof(Player), "Update")]
	internal static class ZoneBuildCameraPlayerUpdatePatch
	{
		private static void Prefix(Player __instance, ref bool __runOriginal)
		{
			if (!ZoneBuildCamera.IsLocalPlayer(__instance) || !ZoneBuildCamera.InBuildMode())
			{
				return;
			}
			if (ZoneBuildCamera.ShouldDeactivateBuildMode(__instance))
			{
				ZoneBuildCamera.DisableBuildMode();
				return;
			}
			__runOriginal = false;
			if (!ZoneBuildCamera.IsInputBlocked(blockPieceSelection: false) && ((Character)__instance).TakeInput())
			{
				UpdateHotbarAndHideInputs(__instance);
				__instance.UpdatePlacement(true, Time.deltaTime);
			}
		}

		private static void Postfix(Player __instance)
		{
			//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 (!ZoneBuildCamera.IsLocalPlayer(__instance) || !ZoneBuildCamera.IsEnabled())
			{
				return;
			}
			KeyboardShortcut toggleHotkey = BuildCameraConfig.ToggleHotkey;
			if (((KeyboardShortcut)(ref toggleHotkey)).IsDown() && !ZoneBuildCamera.IsInputBlocked(blockPieceSelection: true) && ((Character)__instance).TakeInput())
			{
				if (ZoneBuildCamera.InBuildMode())
				{
					ZoneBuildCamera.DisableBuildMode();
				}
				else if (ZoneBuildCamera.ToolIsEquipped(__instance) && ZoneBuildCamera.BuildStationInRange(__instance))
				{
					ZoneBuildCamera.EnableBuildMode();
				}
			}
		}

		private static void UpdateHotbarAndHideInputs(Player player)
		{
			if (Input.GetKeyDown((KeyCode)49) || ZInput.GetButtonDown("Hotbar1"))
			{
				player.UseHotbarItem(1);
			}
			if (Input.GetKeyDown((KeyCode)50) || ZInput.GetButtonDown("Hotbar2"))
			{
				player.UseHotbarItem(2);
			}
			if (Input.GetKeyDown((KeyCode)51) || ZInput.GetButtonDown("Hotbar3"))
			{
				player.UseHotbarItem(3);
			}
			if (Input.GetKeyDown((KeyCode)52) || ZInput.GetButtonDown("Hotbar4"))
			{
				player.UseHotbarItem(4);
			}
			if (Input.GetKeyDown((KeyCode)53) || ZInput.GetButtonDown("Hotbar5"))
			{
				player.UseHotbarItem(5);
			}
			if (Input.GetKeyDown((KeyCode)54) || ZInput.GetButtonDown("Hotbar6"))
			{
				player.UseHotbarItem(6);
			}
			if (Input.GetKeyDown((KeyCode)55) || ZInput.GetButtonDown("Hotbar7"))
			{
				player.UseHotbarItem(7);
			}
			if (Input.GetKeyDown((KeyCode)56) || ZInput.GetButtonDown("Hotbar8"))
			{
				player.UseHotbarItem(8);
			}
			if ((ZInput.GetButtonDown("Hide") || ZInput.GetButtonDown("JoyHide")) && (((Humanoid)player).GetRightItem() != null || ((Humanoid)player).GetLeftItem() != null) && !((Character)player).InAttack())
			{
				((Humanoid)player).HideHandItems(false, true);
			}
		}
	}
	[HarmonyPatch(typeof(PlayerController), "TakeInput")]
	internal static class ZoneBuildCameraPlayerControllerTakeInputPatch
	{
		private static void Prefix(ref bool __result, ref bool __runOriginal)
		{
			if (ZoneBuildCamera.InBuildMode())
			{
				__result = false;
				__runOriginal = false;
			}
		}
	}
	[HarmonyPatch(typeof(GameCamera), "UpdateCamera")]
	[HarmonyBefore(new string[] { "Azumatt.FirstPersonMode" })]
	[HarmonyPriority(700)]
	internal static class ZoneBuildCameraGameCameraUpdatePatch
	{
		private static void Prefix(float dt, GameCamera __instance, ref bool __runOriginal)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (ZoneBuildCamera.InBuildMode())
			{
				ZoneBuildCamera.UpdateBuildCamera(dt, __instance);
				if (ZoneBuildCameraWardCompat.CheckAccess(((Component)__instance).transform.position, flash: false))
				{
					ZoneBuildCamera.AutoPickup(dt, __instance);
				}
				__runOriginal = false;
			}
		}
	}
	internal static class ZoneBuildCameraWardCompat
	{
		private const string WardIsLoveGuid = "Azumatt.WardIsLove";

		private static readonly System.Version WardIsLoveMinimumVersion = new System.Version(2, 3, 3);

		private static MethodInfo? _checkAccessMethod;

		private static bool _checkedWardIsLove;

		internal static bool CheckAccess(Vector3 point, bool flash)
		{
			//IL_007a: 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)
			Player localPlayer = Player.m_localPlayer;
			if (!Object.op_Implicit((Object)(object)localPlayer))
			{
				return false;
			}
			if (IsWardIsLoveLoaded())
			{
				try
				{
					object obj = _checkAccessMethod?.Invoke(null, new object[4]
					{
						localPlayer.GetPlayerID(),
						point,
						0f,
						flash
					});
					bool flag = default(bool);
					int num;
					if (obj is bool)
					{
						flag = (bool)obj;
						num = 1;
					}
					else
					{
						num = 0;
					}
					return (byte)((uint)num & (flag ? 1u : 0u)) != 0;
				}
				catch
				{
					return false;
				}
			}
			return PrivateArea.CheckAccess(point, 0f, flash, true);
		}

		private static bool IsWardIsLoveLoaded()
		{
			if (_checkedWardIsLove)
			{
				return _checkAccessMethod != null;
			}
			_checkedWardIsLove = true;
			if (!Chainloader.PluginInfos.TryGetValue("Azumatt.WardIsLove", out var value) || value.Metadata.Version < WardIsLoveMinimumVersion)
			{
				return false;
			}
			_checkAccessMethod = ((((object)value.Instance)?.GetType().Assembly)?.GetType("WardIsLove.Util.CustomCheck", throwOnError: false))?.GetMethod("CheckAccess", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			return _checkAccessMethod != null;
		}
	}
	internal static class ZoneContentsWithinBlueprintChestPreview
	{
		private sealed class PreviewCache
		{
			public Inventory Inventory { get; }

			public string Signature { get; }

			public float LastUsedAt { get; set; }

			public PreviewCache(Inventory inventory, string signature, float lastUsedAt)
			{
				Inventory = inventory;
				Signature = signature;
				LastUsedAt = lastUsedAt;
			}
		}

		private const string ContentsWithinPatchTypeName = "ContentsWithin.ContentsWithin+InventoryGuiPatch";

		private const int PreviewWidth = 8;

		private const int MaxPreviewRows = 8;

		private static readonly Color RequirementIconColor = new Color(1f, 1f, 1f, 0.45f);

		private static readonly Color RequirementAmountColor = new Color(0.86f, 0.86f, 0.86f, 0.75f);

		private static readonly Color RequirementBackgroundColor = new Color(0.18f, 0.18f, 0.18f, 0.55f);

		private static readonly Dictionary<string, PreviewCache> PreviewInventories = new Dictionary<string, PreviewCache>(StringComparer.Ordinal);

		private static Type? _contentsWithinPatchType;

		private static bool _contentsWithinTypeResolved;

		public static bool IsContentsWithinLoaded()
		{
			Type type;
			return TryGetContentsWithinPatchType(out type);
		}

		public static bool TryGetContentsWithinPatchType(out Type type)
		{
			if (_contentsWithinTypeResolved)
			{
				type = _contentsWithinPatchType;
				return type != null;
			}
			_contentsWithinTypeResolved = true;
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			for (int i = 0; i < assemblies.Length; i++)
			{
				Type type2 = assemblies[i].GetType("ContentsWithin.ContentsWithin+InventoryGuiPatch", throwOnError: false, ignoreCase: false);
				if (!(type2 == null))
				{
					_contentsWithinPatchType = type2;
					type = type2;
					return true;
				}
			}
			type = null;
			return false;
		}

		public static void ResetForWorldSession()
		{
			PreviewInventories.Clear();
		}

		public static bool TryHandleAccess(Container? container, ref bool result)
		{
			if (!Object.op_Implicit((Object)(object)container))
			{
				return false;
			}
			if (IsBlockedPriceChest(container))
			{
				result = false;
				return true;
			}
			if (CanShowVirtualRequirements(container))
			{
				result = true;
				return true;
			}
			return false;
		}

		public static bool TryReplacePreviewInventory(Inventory? source, out Inventory preview)
		{
			preview = null;
			if (source == null || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				return false;
			}
			GameObject hoverObject = ((Humanoid)Player.m_localPlayer).GetHoverObject();
			Container val = (((Object)(object)hoverObject != (Object)null) ? hoverObject.GetComponentInParent<Container>() : null);
			if (!Object.op_Implicit((Object)(object)val) || val.GetInventory() != source)
			{
				return false;
			}
			return TryCreateVirtualRequirementInventory(val, out preview);
		}

		public static void GreyOutRequirementGrid(InventoryGrid? grid)
		{
			if ((Object)(object)grid == (Object)null || !IsVirtualRequirementInventory(grid.GetInventory()))
			{
				return;
			}
			Inventory inventory = grid.GetInventory();
			int num = Mathf.Max(1, grid.m_width);
			int num2 = 0;
			foreach (Element element in grid.m_elements)
			{
				ItemData itemAt = inventory.GetItemAt(num2 % num, num2 / num);
				num2++;
				if (element.m_used)
				{
					ApplyRequirementSlotStyle(element, itemAt);
				}
			}
		}

		private static bool CanShowVirtualRequirements(Container container)
		{
			List<ZoneBlueprintRequirement> requirements;
			string cacheKey;
			return TryGetMissingRequirements(container, out requirements, out cacheKey);
		}

		private static bool IsVirtualRequirementInventory(Inventory? inventory)
		{
			if (inventory == null)
			{
				return false;
			}
			foreach (PreviewCache value in PreviewInventories.Values)
			{
				if (value.Inventory == inventory)
				{
					return true;
				}
			}
			return false;
		}

		private static bool TryCreateVirtualRequirementInventory(Container container, out Inventory preview)
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Expected O, but got Unknown
			preview = null;
			if (!TryGetMissingRequirements(container, out List<ZoneBlueprintRequirement> requirements, out string cacheKey))
			{
				return false;
			}
			string text = CreateRequirementSignature(requirements);
			if (PreviewInventories.TryGetValue(cacheKey, out PreviewCache value) && string.Equals(value.Signature, text, StringComparison.Ordinal))
			{
				value.LastUsedAt = Time.realtimeSinceStartup;
				preview = value.Inventory;
				return true;
			}
			int num = Mathf.Clamp(Mathf.CeilToInt((float)Mathf.Max(1, requirements.Count) / 8f), 1, 8);
			Inventory val = new Inventory("HomesteadRequirementsPreview", container.m_bkg, 8, num);
			FillPreviewInventory(val, requirements);
			PreviewInventories[cacheKey] = new PreviewCache(val, text, Time.realtimeSinceStartup);
			PrunePreviewInventories();
			preview = val;
			return true;
		}

		private static bool TryGetMissingRequirements(Container container, out List<ZoneBlueprintRequirement> requirements, out string cacheKey)
		{
			requirements = new List<ZoneBlueprintRequirement>();
			cacheKey = "";
			if (ZoneBlueprintPlanAnchor.TryGetAnchor(container, out ZoneBlueprintPlanAnchor anchor))
			{
				requirements = anchor.GetMissingRequirementList();
				cacheKey = CreateCacheKey(container, "plan");
				return true;
			}
			ZoneBlueprintStoreChest component = ((Component)container).GetComponent<ZoneBlueprintStoreChest>();
			if ((Object)(object)component != (Object)null && component.IsPurchaseChest())
			{
				requirements = component.GetMissingPurchaseRequirementList();
				cacheKey = CreateCacheKey(container, "purchase");
				return true;
			}
			return false;
		}

		private static void FillPreviewInventory(Inventory inventory, IReadOnlyList<ZoneBlueprintRequirement> requirements)
		{
			//IL_00a2: 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)
			int num = inventory.m_width * inventory.m_height;
			int num2 = Mathf.Min(requirements.Count, num);
			for (int i = 0; i < num2; i++)
			{
				ZoneBlueprintRequirement zoneBlueprintRequirement = requirements[i];
				GameObject val = ZoneBlueprintStore.FindItemPrefab(zoneBlueprintRequirement.PrefabName) ?? ZoneBlueprintStore.FindItemPrefab(zoneBlueprintRequirement.ItemName);
				ItemDrop val2 = (((Object)(object)val != (Object)null) ? val.GetComponent<ItemDrop>() : null);
				if (!((Object)(object)val2 == (Object)null))
				{
					ItemData val3 = val2.m_itemData.Clone();
					val3.m_stack = Mathf.Max(1, zoneBlueprintRequirement.Amount);
					val3.m_dropPrefab = val;
					val3.m_gridPos = new Vector2i(i % inventory.m_width, i / inventory.m_width);
					inventory.m_inventory.Add(val3);
				}
			}
			inventory.Changed();
		}

		private static void ApplyRequirementSlotStyle(Element element, ItemData? item)
		{
			//IL_0061: 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_0047: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)element.m_icon != (Object)null)
			{
				Transform parent = ((Component)element.m_icon).transform.parent;
				if ((Object)(object)parent != (Object)null)
				{
					Image[] componentsInChildren = ((Component)parent).GetComponentsInChildren<Image>(true);
					foreach (Image val in componentsInChildren)
					{
						if (!((Object)(object)val == (Object)(object)element.m_icon))
						{
							((Graphic)val).color = RequirementBackgroundColor;
						}
					}
				}
				((Graphic)element.m_icon).color = RequirementIconColor;
			}
			if ((Object)(object)element.m_amount != (Object)null)
			{
				if (item != null)
				{
					element.m_amount.text = item.m_stack.ToString();
				}
				((Graphic)element.m_amount).color = RequirementAmountColor;
			}
			if ((Object)(object)element.m_quality != (Object)null)
			{
				((Behaviour)element.m_quality).enabled = false;
			}
			if ((Object)(object)element.m_equiped != (Object)null)
			{
				((Behaviour)element.m_equiped).enabled = false;
			}
			if ((Object)(object)element.m_queued != (Object)null)
			{
				((Behaviour)element.m_queued).enabled = false;
			}
			if ((Object)(object)element.m_noteleport != (Object)null)
			{
				((Behaviour)element.m_noteleport).enabled = false;
			}
			if ((Object)(object)element.m_food != (Object)null)
			{
				((Behaviour)element.m_food).enabled = false;
			}
			if ((Object)(object)element.m_durability != (Object)null)
			{
				((Component)element.m_durability).gameObject.SetActive(false);
			}
		}

		private static bool IsBlockedPriceChest(Container container)
		{
			ZoneBlueprintStoreChest component = ((Component)container).GetComponent<ZoneBlueprintStoreChest>();
			if ((Object)(object)component != (Object)null && (component.IsPriceChest() || component.IsPriceChestPrefab()))
			{
				return true;
			}
			ZNetView component2 = ((Component)container).GetComponent<ZNetView>();
			if ((Object)(object)component2 != (Object)null && component2.IsValid())
			{
				return component2.GetZDO().GetPrefab() == ZoneBlueprintStoreChestPrefab.PricePrefabHash;
			}
			return false;
		}

		private static string CreateCacheKey(Container container, string kind)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			ZNetView component = ((Component)container).GetComponent<ZNetView>();
			if ((Object)(object)component != (Object)null && component.IsValid())
			{
				return $"{kind}:{component.GetZDO().m_uid}";
			}
			return $"{kind}:local:{((Object)container).GetInstanceID()}";
		}

		private static string CreateRequirementSignature(IReadOnlyList<ZoneBlueprintRequirement> requirements)
		{
			if (requirements.Count == 0)
			{
				return "empty";
			}
			List<string> list = new List<string>(requirements.Count);
			foreach (ZoneBlueprintRequirement requirement in requirements)
			{
				list.Add($"{requirement.ItemName}|{requirement.PrefabName}|{requirement.Amount}");
			}
			return string.Join(";", list);
		}

		private static void PrunePreviewInventories()
		{
			if (PreviewInventories.Count <= 64)
			{
				return;
			}
			float num = Time.realtimeSinceStartup - 60f;
			List<string> list = new List<string>();
			foreach (KeyValuePair<string, PreviewCache> previewInventory in PreviewInventories)
			{
				if (previewInventory.Value.LastUsedAt < num)
				{
					list.Add(previewInventory.Key);
				}
			}
			foreach (string item in list)
			{
				PreviewInventories.Remove(item);
			}
			while (PreviewInventories.Count > 64)
			{
				string text = "";
				float num2 = float.PositiveInfinity;
				foreach (KeyValuePair<string, PreviewCache> previewInventory2 in PreviewInventories)
				{
					if (!(previewInventory2.Value.LastUsedAt >= num2))
					{
						num2 = previewInventory2.Value.LastUsedAt;
						text = previewInventory2.Key;
					}
				}
				if (!string.IsNullOrEmpty(text))
				{
					PreviewInventories.Remove(text);
					continue;
				}
				break;
			}
		}
	}
	[HarmonyPatch]
	internal static class ZoneContentsWithinAccessCompat
	{
		private static bool Prepare()
		{
			return ZoneContentsWithinBlueprintChestPreview.IsContentsWithinLoaded();
		}

		private static MethodBase? TargetMethod()
		{
			if (!ZoneContentsWithinBlueprintChestPreview.TryGetContentsWithinPatchType(out Type type))
			{
				return null;
			}
			return AccessTools.Method(type, "HasContainerAccess", new Type[1] { typeof(Container) }, (Type[])null);
		}

		private static bool Prefix(Container container, ref bool __result)
		{
			return !ZoneContentsWithinBlueprintChestPreview.TryHandleAccess(container, ref __result);
		}
	}
	[HarmonyPatch]
	internal static class ZoneContentsWithinPreviewCompat
	{
		private static bool Prepare()
		{
			return ZoneContentsWithinBlueprintChestPreview.IsContentsWithinLoaded();
		}

		private static MethodBase? TargetMethod()
		{
			if (!ZoneContentsWithinBlueprintChestPreview.TryGetContentsWithinPatchType(out Type type))
			{
				return null;
			}
			return AccessTools.Method(type, "ShowPreviewContainer", new Type[1] { typeof(Inventory) }, (Type[])null);
		}

		private static void Prefix(ref Inventory container)
		{
			if (ZoneContentsWithinBlueprintChestPreview.TryReplacePreviewInventory(container, out Inventory preview))
			{
				container = preview;
			}
		}
	}
	[HarmonyPatch(typeof(InventoryGrid), "UpdateGui")]
	internal static class ZoneContentsWithinRequirementGridCompat
	{
		private static void Postfix(InventoryGrid __instance)
		{
			ZoneContentsWithinBlueprintChestPreview.GreyOutRequirementGrid(__instance);
		}
	}
	internal static class ZoneBlueprintCommands
	{
		internal sealed class BlueprintLoadPlan
		{
			public List<BlueprintLoadEntry> Entries { get; }

			public List<Vector3> Positions { get; }

			public List<Vector3> SupportContacts { get; }

			public BlueprintLoadPlan(List<BlueprintLoadEntry> entries, List<Vector3> positions, List<Vector3> supportContacts)
			{
				Entries = entries;
				Positions = positions;
				SupportContacts = supportContacts;
			}
		}

		internal sealed class BlueprintLoadEntry
		{
			public ZoneBlueprintEntry Entry { get; }

			public GameObject Prefab { get; }

			public Vector3 Position { get; }

			public Quaternion Rotation { get; }

			public Vector3 Scale { get; }

			public BlueprintLoadEntry(ZoneBlueprintEntry entry, GameObject prefab, Vector3 position, Quaternion rotation, Vector3 scale)
			{
				//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_001c: 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_0024: 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)
				Entry = entry;
				Prefab = prefab;
				Position = position;
				Rotation = rotation;
				Scale = scale;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass13_0
		{
			public BlueprintLoadPlan plan;

			public string planError;

			public bool terrainApplied;

			public int created;

			internal void <FinalizeBlueprintPlanAsync>b__0(BlueprintLoadPlan? value, string error)
			{
				plan = value;
				planError = error;
			}

			internal void <FinalizeBlueprintPlanAsync>b__1(bool result)
			{
				terrainApplied = result;
			}

			internal void <FinalizeBlueprintPlanAsync>b__2(int value)
			{
				created = value;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass13_1
		{
			public string accessReason;

			public List<ZoneBlueprintRequirement> requirements;

			internal void <FinalizeBlueprintPlanAsync>b__3(string value)
			{
				accessReason = value;
			}

			internal void <FinalizeBlueprintPlanAsync>b__4(List<ZoneBlueprintRequirement> value)
			{
				requirements = value;
			}
		}

		[CompilerGenerated]
		private sealed class <CollectRequirementsAsync>d__38 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public IEnumerable<BlueprintLoadEntry> entries;

			public Action<List<ZoneBlueprintRequirement>> onComplete;

			private Dictionary<string, ZoneBlueprintRequirement> <requirements>5__2;

			private int <processedSinceYield>5__3;

			private IEnumerator<BlueprintLoadEntry> <>7__wrap3;

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

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

			[DebuggerHidden]
			public <CollectRequirementsAsync>d__38(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<requirements>5__2 = new Dictionary<string, ZoneBlueprintRequirement>();
						<processedSinceYield>5__3 = 0;
						<>7__wrap3 = entries.GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						break;
					}
					while (<>7__wrap3.MoveNext())
					{
						Piece component = <>7__wrap3.Current.Prefab.GetComponent<Piece>();
						if ((Object)(object)component != (Object)null)
						{
							Requirement[] resources = component.m_resources;
							foreach (Requirement val in resources)
							{
								if (Object.op_Implicit((Object)(object)val.m_resItem) && val.m_amount > 0)
								{
									string name = val.m_resItem.m_itemData.m_shared.m_name;
									if (!<requirements>5__2.TryGetValue(name, out ZoneBlueprintRequirement value))
									{
										value = new ZoneBlueprintRequirement
										{
											ItemName = name,
											PrefabName = Utils.GetPrefabName(((Component)val.m_resItem).gameObject),
											DisplayName = val.m_resItem.m_itemData.m_shared.m_name
										};
										<requirements>5__2[name] = value;
									}
									value.Amount += val.GetAmount(0);
								}
							}
						}
						<processedSinceYield>5__3++;
						if (<processedSinceYield>5__3 >= 250)
						{
							<processedSinceYield>5__3 = 0;
							<>2__current = null;
							<>1__state = 1;
							return true;
						}
					}
					<>m__Finally1();
					<>7__wrap3 = null;
					onComplete(<requirements>5__2.Values.OrderBy<ZoneBlueprintRequirement, string>((ZoneBlueprintRequirement requirement) => requirement.ItemName, StringComparer.Ordinal).ToList());
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

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

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

		[CompilerGenerated]
		private sealed class <CreateLoadPlanAsync>d__34 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public ZoneBlueprintFile blueprint;

			public Action<BlueprintLoadPlan?, string> onComplete;

			public Vector3 anchor;

			public Quaternion anchorRotation;

			private List<BlueprintLoadEntry> <entries>5__2;

			private List<Vector3> <positions>5__3;

			private int <processedSinceYield>5__4;

			private List<Vector3> <supportContacts>5__5;

			private List<ZoneBlueprintEntry>.Enumerator <>7__wrap5;

			private List<ZoneBlueprintTerrainContact>.Enumerator <>7__wrap6;

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

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

			[DebuggerHidden]
			public <CreateLoadPlanAsync>d__34(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				switch (<>1__state)
				{
				case -3:
				case 1:
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
					break;
				case -4:
				case 2:
					try
					{
					}
					finally
					{
						<>m__Finally2();
					}
					break;
				}
				<entries>5__2 = null;
				<positions>5__3 = null;
				<supportContacts>5__5 = null;
				<>7__wrap5 = default(List<ZoneBlueprintEntry>.Enumerator);
				<>7__wrap6 = default(List<ZoneBlueprintTerrainContact>.Enumerator);
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0294: 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_02b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_02be: Unknown result type (might be due to invalid IL or missing references)
				//IL_0164: Unknown result type (might be due to invalid IL or missing references)
				//IL_016a: 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_017a: Unknown result type (might be due to invalid IL or missing references)
				//IL_017f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0184: Unknown result type (might be due to invalid IL or missing references)
				//IL_0187: Unknown result type (might be due to invalid IL or missing references)
				//IL_0192: 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_019c: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b5: 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_01c9: Unknown result type (might be due to invalid IL or missing references)
				bool result;
				try
				{
					switch (<>1__state)
					{
					default:
						result = false;
						goto end_IL_0000;
					case 0:
						<>1__state = -1;
						<entries>5__2 = new List<BlueprintLoadEntry>();
						<positions>5__3 = new List<Vector3>();
						<processedSinceYield>5__4 = 0;
						<>7__wrap5 = blueprint.Entries.GetEnumerator();
						<>1__state = -3;
						goto IL_0213;
					case 1:
						<>1__state = -3;
						goto IL_0213;
					case 2:
						{
							<>1__state = -4;
							break;
						}
						IL_0213:
						while (true)
						{
							if (!<>7__wrap5.MoveNext())
							{
								<>m__Finally1();
								<>7__wrap5 = default(List<ZoneBlueprintEntry>.Enumerator);
								<supportContacts>5__5 = new List<Vector3>(blueprint.TerrainContacts.Count);
								<>7__wrap6 = blueprint.TerrainContacts.GetEnumerator();
								<>1__state = -4;
								break;
							}
							ZoneBlueprintEntry current = <>7__wrap5.Current;
							GameObject prefab = ZNetScene.instance.GetPrefab(current.Prefab);
							if (!Object.op_Implicit((Object)(object)prefab))
							{
								onComplete(null, "Missing prefab '" + current.Prefab + "' while loading blueprint '" + blueprint.Name + "'.");
								result = false;
								goto IL_022b;
							}
							if ((Object)(object)prefab.GetComponent<WearNTear>() != (Object)null && HasBuildRecipe(prefab))
							{
								if (current.LocalPos.Length < 3 || current.LocalRot.Length < 4 || current.Scale.Length < 3)
								{
									onComplete(null, "Blueprint '" + blueprint.Name + "' contains an invalid transform for '" + current.Prefab + "'.");
									result = false;
									goto IL_022b;
								}
								Vector3 val = anchor + anchorRotation * FromVector(current.LocalPos);
								Quaternion rotation = anchorRotation * FromQuaternion(current.LocalRot);
								Vector3 scale = FromVector(current.Scale);
								<entries>5__2.Add(new BlueprintLoadEntry(current, prefab, val, rotation, scale));
								<positions>5__3.Add(val);
							}
							<processedSinceYield>5__4++;
							if (<processedSinceYield>5__4 < 250)
							{
								continue;
							}
							<processedSinceYield>5__4 = 0;
							<>2__current = null;
							<>1__state = 1;
							result = true;
							goto end_IL_0000;
							IL_022b:
							<>m__Finally1();
							goto end_IL_0000;
						}
						break;
					}
					while (true)
					{
						if (<>7__wrap6.MoveNext())
						{
							ZoneBlueprintTerrainContact current2 = <>7__wrap6.Current;
							<supportContacts>5__5.Add(anchor + anchorRotation * new Vector3(current2.LocalX, current2.LocalY, current2.LocalZ));
							<processedSinceYield>5__4++;
							if (<processedSinceYield>5__4 >= 250)
							{
								<processedSinceYield>5__4 = 0;
								<>2__current = null;
								<>1__state = 2;
								result = true;
								break;
							}
							continue;
						}
						<>m__Finally2();
						<>7__wrap6 = default(List<ZoneBlueprintTerrainContact>.Enumerator);
						onComplete(new BlueprintLoadPlan(<entries>5__2, <positions>5__3, <supportContacts>5__5), "");
						result = false;
						break;
					}
					end_IL_0000:;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
				return result;
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>7__wrap5).Dispose();
			}

			private void <>m__Finally2()
			{
				<>1__state = -1;
				((IDisposable)<>7__wrap6).Dispose();
			}

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

		[CompilerGenerated]
		private sealed class <FinalizeBlueprintPlanAsync>d__13 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public string name;

			public Action<HomesteadCommandResult> onComplete;

			public Vector3 anchor;

			public Quaternion anchorRotation;

			private <>c__DisplayClass13_0 <>8__1;

			public Player player;

			private <>c__DisplayClass13_1 <>8__2;

			public Dictionary<string, int> depositedMaterials;

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

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

			[DebuggerHidden]
			public <FinalizeBlueprintPlanAsync>d__13(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//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)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass13_0();
					ZoneBlueprintFile blueprint;
					try
					{
						blueprint = LoadPlanBlueprint(name);
					}
					catch (Exception ex)
					{
						onComplete(HomesteadCommandResult.Fail(ex.Message));
						return false;
					}
					<>8__1.plan = null;
					<>8__1.planError = "";
					<>2__current = CreateLoadPlanAsync(blueprint, anchor, anchorRotation, delegate(BlueprintLoadPlan? value, string error)
					{
						<>8__1.plan = value;
						<>8__1.planError = error;
					});
					<>1__state = 1;
					return true;
				}
				case 1:
				{
					<>1__state = -1;
					if (<>8__1.plan == null)
					{
						onComplete(HomesteadCommandResult.Fail(string.IsNullOrWhiteSpace(<>8__1.planError) ? HomesteadLocalization.Format("hs_blueprint_load_failed_plain", name) : <>8__1.planError));
						return false;
					}
					if (<>8__1.plan.Entries.Count == 0)
					{
						onComplete(HomesteadCommandResult.Fail(HomesteadLocalization.Format("hs_blueprint_no_valid_entries", name)));
						return false;
					}
					if (!ZoneLimitCompat.CanAddWearNTears(<>8__1.plan.Positions, out string reason))
					{
						onComplete(HomesteadCommandResult.Fail(reason));
						return false;
					}
					if (!player.NoCostCheat())
					{
						<>8__2 = new <>c__DisplayClass13_1();
						<>8__2.accessReason = "";
						<>2__current = ValidateBuildAccessWithoutInventoryAsync(player, <>8__1.plan.Entries, delegate(string value)
						{
							<>8__2.accessReason = value;
						});
						<>1__state = 2;
						return true;
					}
					goto IL_0318;
				}
				case 2:
					<>1__state = -1;
					if (!string.IsNullOrEmpty(<>8__2.accessReason))
					{
						onComplete(HomesteadCommandResult.Fail(<>8__2.accessReason));
						return false;
					}
					<>8__2.requirements = new List<ZoneBlueprintRequirement>();
					<>2__current = CollectRequirementsAsync(<>8__1.plan.Entries, delegate(List<ZoneBlueprintRequirement> value)
					{
						<>8__2.requirements = value;
					});
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					foreach (ZoneBlueprintRequirement requirement in <>8__2.requirements)
					{
						depositedMaterials.TryGetValue(requirement.ItemName, out var value2);
						if (value2 < requirement.Amount)
						{
							onComplete(HomesteadCommandResult.Fail(HomesteadLocalization.Format("hs_blueprint_missing_deposited", HomesteadLocalization.MaybeLocalize(requirement.DisplayName), value2, requirement.Amount)));
							return false;
						}
					}
					<>8__2 = null;
					goto IL_0318;
				case 4:
					<>1__state = -1;
					goto IL_0385;
				case 5:
					{
						<>1__state = -1;
						onComplete(HomesteadCommandResult.Ok(HomesteadLocalization.Format("hs_blueprint_confirmed", name, <>8__1.created, <>8__1.terrainApplied ? HomesteadLocalization.Text("hs_common_yes") : HomesteadLocalization.Text("hs_common_no"))));
						return false;
					}
					IL_0385:
					<>8__1.created = 0;
					<>2__current = SpawnPlanAsync(<>8__1.plan, player, delegate(int value)
					{
						<>8__1.created = value;
					});
					<>1__state = 5;
					return true;
					IL_0318:
					<>8__1.terrainApplied = false;
					if (BlueprintConfig.ShouldApplyTerrainSupport(player) && <>8__1.plan.SupportContacts.Count > 0)
					{
						<>2__current = BlueprintTerrainApplier.ApplySupportContactsAsync(<>8__1.plan.SupportContacts, delegate(bool result)
						{
							<>8__1.terrainApplied = result;
						});
						<>1__state = 4;
						return true;
					}
					goto IL_0385;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <SpawnPlanAsync>d__36 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Player player;

			public BlueprintLoadPlan plan;

			public Action<int> onComplete;

			private long <playerId>5__2;

			private string <playerName>5__3;

			private int <created>5__4;

			private int <processedSinceYield>5__5;

			private List<BlueprintLoadEntry>.Enumerator <>7__wrap5;

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

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

			[DebuggerHidden]
			public <SpawnPlanAsync>d__36(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<playerName>5__3 = null;
				<>7__wrap5 = default(List<BlueprintLoadEntry>.Enumerator);
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00b5: 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_00c1: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<playerId>5__2 = player.GetPlayerID();
						<playerName>5__3 = player.GetPlayerName();
						<created>5__4 = 0;
						<processedSinceYield>5__5 = 0;
						<>7__wrap5 = plan.Entries.GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						break;
					}
					while (<>7__wrap5.MoveNext())
					{
						BlueprintLoadEntry current = <>7__wrap5.Current;
						SavedZdoData data = (string.IsNullOrEmpty(current.Entry.Data) ? new SavedZdoData() : new SavedZdoData(current.Entry.Data));
						SanitizeBlueprintData(data);
						ZDO val = SavedZdoHelper.Init(current.Prefab, current.Position, current.Rotation, current.Scale, data, EmptyParameters);
						if (val != null)
						{
							val.Set(ZDOVars.s_creator, <playerId>5__2);
							val.Set(ZDOVars.s_creatorName, <playerName>5__3);
							val.Set(BlueprintPlacedHash, true);
							ZNetScene.instance.CreateObject(val);
							<created>5__4++;
						}
						<processedSinceYield>5__5++;
						if (<processedSinceYield>5__5 >= 250)
						{
							<processedSinceYield>5__5 = 0;
							<>2__current = null;
							<>1__state = 1;
							return true;
						}
					}
					<>m__Finally1();
					<>7__wrap5 = default(List<BlueprintLoadEntry>.Enumerator);
					onComplete(<created>5__4);
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>7__wrap5).Dispose();
			}

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

		[CompilerGenerated]
		private sealed class <ValidateBuildAccessWithoutInventoryAsync>d__40 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public IEnumerable<BlueprintLoadEntry> entries;

			public Player player;

			public Action<string> onComplete;

			private int <processedSinceYield>5__2;

			private IEnumerator<BlueprintLoadEntry> <>7__wrap2;

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

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

			[DebuggerHidden]
			public <ValidateBuildAccessWithoutInventoryAsync>d__40(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
				bool result;
				try
				{
					switch (<>1__state)
					{
					default:
						result = false;
						goto end_IL_0000;
					case 0:
						<>1__state = -1;
						<processedSinceYield>5__2 = 0;
						<>7__wrap2 = entries.GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						break;
					}
					while (true)
					{
						if (<>7__wrap2.MoveNext())
						{
							BlueprintLoadEntry current = <>7__wrap2.Current;
							Piece component = current.Prefab.GetComponent<Piece>();
							if ((Object)(object)component != (Object)null)
							{
								if (!player.HaveRequirements(component, (RequirementMode)1))
								{
									onComplete(HomesteadLocalization.Format("hs_blueprint_missing_known_station_or_materials", current.Entry.Prefab));
									result = false;
								}
								else
								{
									if (!((Object)(object)component.m_craftingStation != (Object)null) || Object.op_Implicit((Object)(object)CraftingStation.HaveBuildStationInRange(component.m_craftingStation.m_name, ((Component)player).transform.position)) || ZoneSystem.instance.GetGlobalKey((GlobalKeys)22))
									{
										goto IL_0117;
									}
									onComplete(HomesteadLocalization.Format("hs_blueprint_missing_crafting_station", current.Entry.Prefab));
									result = false;
								}
								<>m__Finally1();
								break;
							}
							goto IL_0117;
						}
						<>m__Finally1();
						<>7__wrap2 = null;
						onComplete("");
						result = false;
						break;
						IL_0117:
						<processedSinceYield>5__2++;
						if (<processedSinceYield>5__2 >= 250)
						{
							<processedSinceYield>5__2 = 0;
							<>2__current = null;
							<>1__state = 1;
							result = true;
							break;
						}
					}
					end_IL_0000:;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
				return result;
			}

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

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

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

		private const int BlueprintPlanBatchSize = 250;

		private const string BlueprintPieceMarkerKey = "sighsorry.Homestead.blueprint_piece";

		private static readonly int BlueprintPlacedHash = StringExtensionMethods.GetStableHashCode("sighsorry.Homestead.blueprint_piece");

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

		private static readonly Dictionary<string, bool> BuildRecipeCache = new Dictionary<string, bool>(StringComparer.Ordinal);

		private static ManualLogSource _logger = null;

		private static bool _initialized;

		private static int _buildRecipeCacheObjectDbCount = -1;

		public static void Initialize(ManualLogSource logger)
		{
			if (!_initialized)
			{
				_initialized = true;
				_logger = logger;
				ZoneBlueprintPlanRpc.Initialize(logger);
			}
		}

		internal static HomesteadCommandResult SaveSelectedBlueprint(string name, Player player)
		{
			EnsureWorldReady();
			name = (name ?? "").Trim();
			if (string.IsNullOrWhiteSpace(name))
			{
				return HomesteadCommandResult.Fail(HomesteadLocalization.Text("hs_blueprint_name_required"));
			}
			if (!ZoneBlueprintSaveTool.TryGetSelectedBlueprint(name, player, out ZoneBlueprintFile blueprint, out string reason))
			{
				return HomesteadCommandResult.Fail(reason);
			}
			if (blueprint.Entries.Count == 0)
			{
				return HomesteadCommandResult.Fail(HomesteadLocalization.Text("hs_blueprint_no_selected_wearnttear"));
			}
			string text = SaveBlueprint(name, blueprint);
			return HomesteadCommandResult.Ok(HomesteadLocalization.Format("hs_blueprint_saved_to_path", name, blueprint.Entries.Count, blueprint.TerrainContacts.Count, text));
		}

		internal static HomesteadCommandResult PlaceBlueprintPlanAt(string name, Player player, Vector3 anchor, Quaternion anchorRotation)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			return PlaceBlueprintPlanAt(name, player, anchor, anchorRotation, anchorRotation);
		}

		internal static HomesteadCommandResult PlaceBlueprintPlanAt(string name, Player player, Vector3 anchor, Quaternion anchorRotation, Quaternion chestRotation)
		{
			//IL_0008: 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_000a: 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_0011: 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_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: 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_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			ZoneBlueprintFile blueprint = LoadBlueprint(name);
			Vector3 planChestPosition = GetPlanChestPosition(blueprint, anchor, anchorRotation, chestRotation);
			if ((Object)(object)ZNet.instance != (Object)null && !ZNet.instance.IsServer())
			{
				ZoneBlueprintPlanRpc.RequestPlace(name, blueprint, anchor, anchorRotation, planChestPosition, chestRotation);
				return HomesteadCommandResult.Ok(HomesteadLocalization.Format("hs_blueprint_plan_request_sent", name));
			}
			if (CreateLoadPlan(blueprint, anchor, anchorRotation).Entries.Count == 0)
			{
				return HomesteadCommandResult.Fail(HomesteadLocalization.Format("hs_blueprint_no_valid_entries", name));
			}
			return ZoneBlueprintPlanChestPrefab.PlacePlanChest(name, player, anchor, anchorRotation, planChestPosition, chestRotation);
		}

		internal static HomesteadCommandResult FinalizeBlueprintPlan(string name, Player player, Vector3 anchor, Quaternion anchorRotation, IReadOnlyDictionary<string, int> depositedMaterials)
		{
			//IL_0006: 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)
			BlueprintLoadPlan blueprintLoadPlan = CreateLoadPlan(LoadBlueprint(name), anchor, anchorRotation);
			if (blueprintLoadPlan.Entries.Count == 0)
			{
				return HomesteadCommandResult.Fail(HomesteadLocalization.Format("hs_blueprint_no_valid_entries", name));
			}
			if (!ZoneLimitCompat.CanAddWearNTears(blueprintLoadPlan.Positions, out string reason))
			{
				return HomesteadCommandResult.Fail(reason);
			}
			if (!player.NoCostCheat())
			{
				string text = ValidateBuildAccessWithoutInventory(player, blueprintLoadPlan.Entries);
				if (!string.IsNullOrEmpty(text))
				{
					return HomesteadCommandResult.Fail(text);
				}
				foreach (ZoneBlueprintRequirement item in CollectRequirements(blueprintLoadPlan))
				{
					depositedMaterials.TryGetValue(item.ItemName, out var value);
					if (value < item.Amount)
					{
						return HomesteadCommandResult.Fail(HomesteadLocalization.Format("hs_blueprint_missing_deposited", HomesteadLocalization.MaybeLocalize(item.DisplayName), value, item.Amount));
					}
				}
			}
			bool flag = false;
			if (BlueprintConfig.ShouldApplyTerrainSupport(player) && blueprintLoadPlan.SupportContacts.Count > 0)
			{
				flag = BlueprintTerrainApplier.ApplySupportContacts(blueprintLoadPlan.SupportContacts);
			}
			int num = SpawnPlan(blueprintLoadPlan, player);
			return HomesteadCommandResult.Ok(HomesteadLocalization.Format("hs_blueprint_confirmed", name, num, flag ? HomesteadLocalization.Text("hs_common_yes") : HomesteadLocalization.Text("hs_common_no")));
		}

		[IteratorStateMachine(typeof(<FinalizeBlueprintPlanAsync>d__13))]
		internal static IEnumerator FinalizeBlueprintPlanAsync(string name, Player player, Vector3 anchor, Quaternion anchorRotation, Dictionary<string, int> depositedMaterials, Action<HomesteadCommandResult> onComplete)
		{
			//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_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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FinalizeBlueprintPlanAsync>d__13(0)
			{
				name = name,
				player = player,
				anchor = anchor,
				anchorRotation = anchorRotation,
				depositedMaterials = depositedMaterials,
				onComplete = onComplete
			};
		}

		internal static List<string> GetBlueprintNames()
		{
			string worldBlueprintDirectory = GetWorldBlueprintDirectory();
			if (!Directory.Exists(worldBlueprintDirectory))
			{
				return new List<string>();
			}
			return (from path in Directory.GetFiles(worldBlueprintDirectory, "*.hsbp.yml")
				select Path.GetFileName(path).Replace(".hsbp.yml", "")).OrderBy<string, string>((string name) => name, StringComparer.OrdinalIgnoreCase).ToList();
		}

		internal static bool TryLoadBlueprint(string name, out ZoneBlueprintFile blueprint)
		{
			try
			{
				blueprint = LoadBlueprint(name);
				return true;
			}
			catch
			{
				blueprint = null;
				return false;
			}
		}

		internal static string SerializeBlueprintForStore(string name)
		{
			return HomesteadYaml.Serialize(LoadBlueprint(name));
		}

		internal static string SaveBlueprintFromStore(string preferredName, ZoneBlueprintFile blueprint)
		{
			string name = (blueprint.Name = GetUniqueBlueprintName(preferredName));
			return SaveBlueprint(name, blueprint);
		}

		internal static List<ZDO> FindBlueprintWearNTearZdos(Player player, ZoneAreaSelection selection, BlueprintAreaSaveCreatorMode creatorMode)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			long playerID = player.GetPlayerID();
			List<ZDO> list = new List<ZDO>();
			List<ZDO> list2 = new List<ZDO>();
			ZoneAreaTargetOverlay.CollectNearbyZdos(selection, list2);
			foreach (ZDO item in list2)
			{
				if (!IsHomesteadBlueprintChest(item) && TryReadSavableWearNTear(item, out GameObject _) && selection.Contains(item.GetPosition()))
				{
					long @long = item.GetLong(ZDOVars.s_creator, 0L);
					if (IsAreaSaveCreatorAllowed(playerID, @long, creatorMode))
					{
						list.Add(item);
					}
				}
			}
			return list;
		}

		internal static bool IsAreaSaveCreatorAllowed(long playerId, long creator, BlueprintAreaSaveCreatorMode creatorMode)
		{
			if (creator == playerId)
			{
				return true;
			}
			return creatorMode switch
			{
				BlueprintAreaSaveCreatorMode.AllCreators => true, 
				BlueprintAreaSaveCreatorMode.OwnedAndCreatorless => creator == 0, 
				_ => false, 
			};
		}

		internal static bool IsHomesteadBlueprintChest(ZDO zdo)
		{
			if (zdo == null || !zdo.IsValid())
			{
				return false;
			}
			int prefab = zdo.GetPrefab();
			if (prefab != ZoneBlueprintPlanChestPrefab.PrefabHash)
			{
				return ZoneBlueprintStoreChestPrefab.IsStorePrefab(prefab);
			}
			return true;
		}

		internal static bool IsHomesteadBlueprintChestPrefab(GameObject? prefab)
		{
			if (!Object.op_Implicit((Object)(object)prefab))
			{
				return false;
			}
			string prefabName = Utils.GetPrefabName(prefab);
			if (!string.Equals(prefabName, "piece_chest_wood_blueprint", StringComparison.OrdinalIgnoreCase))
			{
				return ZoneBlueprintStoreChestPrefab.IsStorePrefabName(prefabName);
			}
			return true;
		}

		internal static ZoneBlueprintFile CaptureBlueprintFromZdos(string name, Player player, Vector3 anchor, Quaternion anchorRotation, IEnumerable<ZDO> sourceZdos, float radius)
		{
			//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_0006: 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)
			//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_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_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: 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_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_00b4: 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_00ce: 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_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_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			Quaternion val = Quaternion.Inverse(anchorRotation);
			List<ZoneBlueprintEntry> list = new List<ZoneBlueprintEntry>();
			List<TerrainContactSource> list2 = new List<TerrainContactSource>();
			int num = 0;
			foreach (ZDO item in sourceZdos.ToList())
			{
				if (TryReadSavableWearNTear(item, out GameObject prefab))
				{
					Vector3 position = item.GetPosition();
					Quaternion rotation = item.GetRotation();
					Vector3 val2 = ReadScale(item, prefab);
					SavedZdoData savedZdoData = new SavedZdoData(item);
					SanitizeBlueprintData(savedZdoData);
					Vector3 value = val * (position - anchor);
					Quaternion value2 = val * rotation;
					list.Add(new ZoneBlueprintEntry
					{
						SaveId = $"w{++num:D4}",
						Prefab = Utils.GetPrefabName(prefab),
						LocalPos = ToArray(value),
						LocalRot = ToArray(value2),
						Scale = ToArray(val2),
						Data = savedZdoData.GetBase64(EmptyParameters)
					});
					list2.Add(new TerrainContactSource(prefab, position, rotation, val2));
				}
			}
			return new ZoneBlueprintFile
			{
				Name = name,
				World = GetWorldName(),
				SavedAt = HomesteadTimestamp.Now(),
				Radius = radius,
				Entries = list.OrderBy<ZoneBlueprintEntry, string>((ZoneBlueprintEntry entry) => entry.Prefab, StringComparer.Ordinal).ThenBy((ZoneBlueprintEntry entry) => entry.LocalPos[0]).ThenBy((ZoneBlueprintEntry entry) => entry.LocalPos[2])
					.ThenBy((ZoneBlueprintEntry entry) => entry.LocalPos[1])
					.ToList(),
				TerrainContacts = BlueprintTerrainApplier.CaptureContacts(anchor, val, list2)
			};
		}

		internal static ZoneBlueprintFile LoadBlueprintForPlan(string name)
		{
			return LoadPlanBlueprint(name);
		}

		internal static BlueprintLoadPlan CreateLoadPlanForBlueprint(string name, Vector3 anchor, Quaternion anchorRotation)
		{
			//IL_0006: 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)
			return CreateLoadPlan(LoadPlanBlueprint(name), anchor, anchorRotation);
		}

		internal static BlueprintLoadPlan CreateLoadPlanForBlueprint(ZoneBlueprintFile blueprint, Vector3 anchor, Quaternion anchorRotation)
		{
			//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)
			return CreateLoadPlan(blueprint, anchor, anchorRotation);
		}

		internal static HomesteadCommandResult SaveUploadedBlueprintForPlan(string preferredName, ZoneBlueprintFile blueprint, long playerId, out string savedName)
		{
			savedName = "";
			string text = ValidateBlueprintFile(blueprint);
			if (!string.IsNullOrWhiteSpace(text))
			{
				return HomesteadCommandResult.Fail(text);
			}
			string text2 = SanitizePathSegment(string.IsNullOrWhiteSpace(preferredName) ? blueprint.Name : preferredName);
			string planGhostBlueprintPath = GetPlanGhostBlueprintPath(text2);
			Directory.CreateDirectory(Path.GetDirectoryName(planGhostBlueprintPath));
			blueprint.World = GetWorldName();
			if (File.Exists(planGhostBlueprintPath))
			{
				try
				{
					string a = HomesteadYaml.Serialize(HomesteadYaml.Deserialize<ZoneBlueprintFile>(File.ReadAllText(planGhostBlueprintPath)));
					string b = HomesteadYaml.Serialize(CloneForName(blueprint, text2));
					if (string.Equals(a, b, StringComparison.Ordinal))
					{
						savedName = text2;
						return HomesteadCommandResult.Ok(HomesteadLocalization.Format("hs_blueprint_server_already_has", savedName));
					}
				}
				catch
				{
				}
				text2 = GetUniquePlanGhostBlueprintName($"{text2}_p{Math.Abs(playerId)}");
			}
			blueprint.Name = text2;
			string planGhostBlueprintPath2 = GetPlanGhostBlueprintPath(text2);
			Directory.CreateDirectory(Path.GetDirectoryName(planGhostBlueprintPath2));
			File.WriteAllText(planGhostBlueprintPath2, HomesteadYaml.Serialize(blueprint));
			savedName = text2;
			return HomesteadCommandResult.Ok(HomesteadLocalization.Format("hs_blueprint_uploaded_to_server", savedName));
		}

		internal static string SerializePreviewBlueprintForPlan(string name)
		{
			if (!ZoneBlueprintNetworkPayload.TryCreatePreviewYaml(LoadPlanBlueprint(name), out string previewYaml, out string reason))
			{
				throw new InvalidOperationException(reason);
			}
			return previewYaml;
		}

		internal static void EnsureLocalPlanBlueprintCopy(string name, string blueprintYaml)
		{
			if (!string.IsNullOrWhiteSpace(name) && !string.IsNullOrWhiteSpace(blueprintYaml))
			{
				ZoneBlueprintFile zoneBlueprintFile = HomesteadYaml.Deserialize<ZoneBlueprintFile>(blueprintYaml);
				zoneBlueprintFile.Name = name;
				string planGhostBlueprintPath = GetPlanGhostBlueprintPath(name);
				Directory.CreateDirectory(Path.GetDirectoryName(planGhostBlueprintPath));
				File.WriteAllText(planGhostBlueprintPath, HomesteadYaml.Serialize(zoneBlueprintFile));
			}
		}

		internal static List<ZoneBlueprintRequirement> CollectRequirements(BlueprintLoadPlan plan)
		{
			return CollectRequirements(plan.Entries);
		}

		internal static List<ZoneBlueprintCraftingStationRequirement> CollectCraftingStations(BlueprintLoadPlan plan)
		{
			Dictionary<string, ZoneBlueprintCraftingStationRequirement> dictionary = new Dictionary<string, ZoneBlueprintCraftingStationRequirement>(StringComparer.Ordinal);
			foreach (BlueprintLoadEntry entry in plan.Entries)
			{
				Piece component = entry.Prefab.GetComponent<Piece>();
				CraftingStation val = (((Object)(object)component != (Object)null) ? component.m_craftingStation : null);
				if (!((Object)(object)val == (Object)null))
				{
					string name = val.m_name;
					if (!string.IsNullOrWhiteSpace(name) && !dictionary.ContainsKey(name))
					{
						dictionary[name] = new ZoneBlueprintCraftingStationRequirement
						{
							StationName = name,
							PrefabName = Utils.GetPrefabName(((Component)val).gameObject),
							DisplayName = name
						};
					}
				}
			}
			return dictionary.Values.OrderBy<ZoneBlueprintCraftingStationRequirement, string>((ZoneBlueprintCraftingStationRequirement station) => station.StationName, StringComparer.Ordinal).ToList();
		}

		internal static Vector3 GetPlanChestPosition(ZoneBlueprintFile blueprint, Vector3 anchor, Quaternion anchorRotation)
		{
			//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_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			return GetPlanChestPosition(blueprint, anchor, anchorRotation, anchorRotation);
		}

		internal static Vector3 GetPlanChestPosition(ZoneBlueprintFile blueprint, Vector3 anchor, Quaternion anchorRotation, Quaternion chestRotation)
		{
			//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_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_001a: 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_00d2: 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_00d5: 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_00e3: 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_00f1: 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)
			if (blueprint.Entries.Count == 0)
			{
				return anchor;
			}
			Quaternion inverseChestRotation = Quaternion.Inverse(chestRotation);
			List<Vector3> source = blueprint.Entries.Select((ZoneBlueprintEntry entry) => inverseChestRotation * (anchorRotation * FromVector(entry.LocalPos))).ToList();
			float num = source.Min((Vector3 position) => position.x);
			float num2 = source.Max((Vector3 position) => position.x);
			float num3 = source.Min((Vector3 position) => position.z);
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor((num + num2) * 0.5f, 0f, num3 - 2.5f);
			Vector3 val2 = anchor + chestRotation * val;
			val2.y = SampleGroundY(val2.x, val2.z, anchor.y);
			return val2;
		}

		private static BlueprintLoadPlan CreateLoadPlan(ZoneBlueprintFile blueprint, Vector3 anchor, Quaternion anchorRotation)
		{
			//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_000e: 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_00ac: 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_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_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_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: 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_00f4: 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_00fd: 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)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			List<BlueprintLoadEntry> list = new List<BlueprintLoadEntry>();
			List<Vector3> list2 = new List<Vector3>();
			foreach (ZoneBlueprintEntry entry in blueprint.Entries)
			{
				GameObject prefab = ZNetScene.instance.GetPrefab(entry.Prefab);
				if (!Object.op_Implicit((Object)(object)prefab))
				{
					throw new InvalidOperationException("Missing prefab '" + entry.Prefab + "' while loading blueprint '" + blueprint.Name + "'.");
				}
				if (!((Object)(object)prefab.GetComponent<WearNTear>() == (Object)null) && HasBuildRecipe(prefab))
				{
					Vector3 val = anchor + anchorRotation * FromVector(entry.LocalPos);
					Quaternion rotation = anchorRotation * FromQuaternion(entry.LocalRot);
					Vector3 scale = FromVector(entry.Scale);
					list.Add(new BlueprintLoadEntry(entry, prefab, val, rotation, scale));
					list2.Add(val);
				}
			}
			List<Vector3> supportContacts = blueprint.TerrainContacts.Select((ZoneBlueprintTerrainContact contact) => anchor + anchorRotation * new Vector3(contact.LocalX, contact.LocalY, contact.LocalZ)).ToList();
			return new BlueprintLoadPlan(list, list2, supportContacts);
		}

		[IteratorStateMachine(typeof(<CreateLoadPlanAsync>d__34))]
		private static IEnumerator CreateLoadPlanAsync(ZoneBlueprintFile blueprint, Vector3 anchor, Quaternion anchorRotation, Action<BlueprintLoadPlan?, string> onComplete)
		{
			//IL_000e: 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_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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <CreateLoadPlanAsync>d__34(0)
			{
				blueprint = blueprint,
				anchor = anchor,
				anchorRotation = anchorRotation,
				onComplete = onComplete
			};
		}

		private static int SpawnPlan(BlueprintLoadPlan plan, Player player)
		{
			//IL_0067: 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_0075: Unknown result type (might be due to invalid IL or missing references)
			long playerID = player.GetPlayerID();
			string playerName = player.GetPlayerName();
			int num = 0;
			foreach (BlueprintLoadEntry entry in plan.Entries)
			{
				SavedZdoData data = (string.IsNullOrEmpty(entry.Entry.Data) ? new SavedZdoData() : new SavedZdoData(entry.Entry.Data));
				SanitizeBlueprintData(data);
				ZDO val = SavedZdoHelper.Init(entry.Prefab, entry.Position, entry.Rotation, entry.Scale, data, EmptyParameters);
				if (val != null)
				{
					val.Set(ZDOVars.s_creator, playerID);
					val.Set(ZDOVars.s_creatorName, playerName);
					val.Set(BlueprintPlacedHash, true);
					ZNetScene.instance.CreateObject(val);
					num++;
				}
			}
			return num;
		}

		[IteratorStateMachine(typeof(<SpawnPlanAsync>d__36))]
		private static IEnumerator SpawnPlanAsync(BlueprintLoadPlan plan, Player player, Action<int> onComplete)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SpawnPlanAsync>d__36(0)
			{
				plan = plan,
				player = player,
				onComplete = onComplete
			};
		}

		private static List<ZoneBlueprintRequirement> CollectRequirements(IEnumerable<BlueprintLoadEntry> entries)
		{
			Dictionary<string, ZoneBlueprintRequirement> dictionary = new Dictionary<string, ZoneBlueprintRequirement>();
			foreach (BlueprintLoadEntry entry in entries)
			{
				Piece component = entry.Prefab.GetComponent<Piece>();
				if ((Object)(object)component == (Object)null)
				{
					continue;
				}
				Requirement[] resources = component.m_resources;
				foreach (Requirement val in resources)
				{
					if (Object.op_Implicit((Object)(object)val.m_resItem) && val.m_amount > 0)
					{
						string name = val.m_resItem.m_itemData.m_shared.m_name;
						if (!dictionary.TryGetValue(name, out var value))
						{
							value = (dictionary[name] = new ZoneBlueprintRequirement
							{
								ItemName = name,
								PrefabName = Utils.GetPrefabName(((Component)val.m_resItem).gameObject),
								DisplayName = val.m_resItem.m_itemData.m_shared.m_name
							});
						}
						value.Amount += val.GetAmount(0);
					}
				}
			}
			return dictionary.Values.OrderBy<ZoneBlueprintRequirement, string>((ZoneBlueprintRequirement requirement) => requirement.ItemName, StringComparer.Ordinal).ToList();
		}

		[IteratorStateMachine(typeof(<CollectRequirementsAsync>d__38))]
		private static IEnumerator CollectRequirementsAsync(IEnumerable<BlueprintLoadEntry> entries, Action<List<ZoneBlueprintRequirement>> onComplete)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <CollectRequirementsAsync>d__38(0)
			{
				entries = entries,
				onComplete = onComplete
			};
		}

		private static string ValidateBuildAccessWithoutInventory(Player player, IEnumerable<BlueprintLoadEntry> entries)
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			foreach (BlueprintLoadEntry entry in entries)
			{
				Piece component = entry.Prefab.GetComponent<Piece>();
				if (!((Object)(object)component == (Object)null))
				{
					if (!player.HaveRequirements(component, (RequirementMode)1))
					{
						return HomesteadLocalization.Format("hs_blueprint_missing_known_station_or_materials", entry.Entry.Prefab);
					}
					if ((Object)(object)component.m_craftingStation != (Object)null && !Object.op_Implicit((Object)(object)CraftingStation.HaveBuildStationInRange(component.m_craftingStation.m_name, ((Component)player).transform.position)) && !ZoneSystem.instance.GetGlobalKey((GlobalKeys)22))
					{
						return HomesteadLocalization.Format("hs_blueprint_missing_crafting_station", entry.Entry.Prefab);
					}
				}
			}
			return "";
		}

		[IteratorStateMachine(typeof(<ValidateBuildAccessWithoutInventoryAsync>d__40))]
		private static IEnumerator ValidateBuildAccessWithoutInventoryAsync(Player player, IEnumerable<BlueprintLoadEntry> entries, Action<string> onComplete)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ValidateBuildAccessWithoutInventoryAsync>d__40(0)
			{
				player = player,
				entries = entries,
				onComplete = onComplete
			};
		}

		internal static bool TryReadWearNTear(ZDO zdo, out GameObject prefab)
		{
			prefab = null;
			if (zdo == null || !zdo.IsValid())
			{
				return false;
			}
			prefab = ZNetScene.instance.GetPrefab(zdo.GetPrefab());
			if (Object.op_Implicit((Object)(object)prefab) && (Object)(object)prefab.GetComponent<WearNTear>() != (Object)null)
			{
				return (Object)(object)prefab.GetComponent<ZNetView>() != (Object)null;
			}
			return false;
		}

		internal static bool TryReadSavableWearNTear(ZDO zdo, out GameObject prefab)
		{
			if (TryReadWearNTear(zdo, out prefab))
			{
				return HasBuildRecipe(prefab);
			}
			return false;
		}

		internal static bool HasBuildRecipe(GameObject? prefab)
		{
			if (!Object.op_Implicit((Object)(object)prefab))
			{
				return false;
			}
			Piece component = prefab.GetComponent<Piece>();
			if ((Object)(object)component == (Object)null || component.m_resources == null)
			{
				return false;
			}
			if (HasResourceCost(component))
			{
				return IsRegisteredPlayerBuildPiece(prefab);
			}
			return false;
		}

		private static bool HasResourceCost(Piece piece)
		{
			return piece.m_resources.Any((Requirement requirement) => Object.op_Implicit((Object)(object)requirement.m_resItem) && requirement.m_amount > 0);
		}

		private static bool IsRegisteredPlayerBuildPiece(GameObject prefab)
		{
			string prefabName = Utils.GetPrefabName(prefab);
			if (string.IsNullOrWhiteSpace(prefabName))
			{
				return false;
			}
			ObjectDB instance = ObjectDB.instance;
			if ((Object)(object)instance == (Object)null || instance.m_items == null)
			{
				return false;
			}
			if (_buildRecipeCacheObjectDbCount != instance.m_items.Count)
			{
				BuildRecipeCache.Clear();
				_buildRecipeCacheObjectDbCount = instance.m_items.Count;
			}
			if (BuildRecipeCache.TryGetValue(prefabName, out var value))
			{
				return value;
			}
			foreach (GameObject item in instance.m_items)
			{
				PieceTable val = (Object.op_Implicit((Object)(object)item) ? item.GetComponent<ItemDrop>() : null)?.m_itemData.m_shared.m_buildPieces;
				if (val?.m_pieces != null && val.m_pieces.Any((GameObject piecePrefab) => Object.op_Implicit((Object)(object)piecePrefab) && string.Equals(Utils.GetPrefabName(piecePrefab), prefabName, StringComparison.Ordinal)))
				{
					BuildRecipeCache[prefabName] = true;
					return true;
				}
			}
			BuildRecipeCache[prefabName] = false;
			return false;
		}

		private static void SanitizeBlueprintData(SavedZdoData data)
		{
			//IL_0001: 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)
			data.OriginalId = ZDOID.None;
			data.TargetConnectionId = ZDOID.None;
			data.ConnectionHash = 0;
			data.ConnectionType = (ConnectionType)0;
			RemoveKey(data, ZDOVars.s_creator);
			RemoveKey(data, ZDOVars.s_creatorName);
			RemoveKey(data, ZDOVars.s_health);
			RemoveKey(data, ZDOVars.s_support);
			RemoveKey(data, ZDOVars.s_inUse);
			RemoveKey(data, ZDOVars.s_user);
			KeyValuePair<int, int> s_zdoidUser = ZDOVars.s_zdoidUser;
			RemoveKey(data, s_zdoidUser.Key);
			s_zdoidUser = ZDOVars.s_zdoidUser;
			RemoveKey(data, s_zdoidUser.Value);
			RemoveKey(data, ZDOVars.s_bodyAVelHash);
			RemoveKey(data, ZDOVars.s_bodyVelHash);
			RemoveKey(data, ZDOVars.s_bodyVelocity);
			RemoveKey(data, ZDOVars.s_velHash);
			RemoveKey(data, ZDOVars.s_initVel);
			RemoveKey(data, ZDOVars.s_forward);
			RemoveKey(data, ZDOVars.s_landed);
			RemoveKey(data, ZDOVars.s_inWater);
			RemoveKey(data, ZDOVars.s_hitDir);
			RemoveKey(data, ZDOVars.s_hitPoint);
			RemoveKey(data, ZDOVars.s_startTime);
			RemoveKey(data, ZDOVars.s_lastTime);
			RemoveKey(data, ZDOVars.s_aliveTime);
			RemoveKey(data, ZDOVars.s_accTime);
			RemoveKey(data, ZDOVars.s_worldTimeHash);
		}

		private static void RemoveKey(SavedZdoData data, int hash)
		{
			data.Strings?.Remove(hash);
			data.Floats?.Remove(hash);
			data.Ints?.Remove(hash);
			data.Bools?.Remove(hash);
			data.Hashes?.Remove(hash);
			data.Longs?.Remove(hash);
			data.Vecs?.Remove(hash);
			data.Quats?.Remove(hash);
			data.ByteArrays?.Remove(hash);
		}

		private static ZoneBlueprintFile LoadBlueprint(string name)
		{
			string blueprintPath = GetBlueprintPath(name);
			if (!File.Exists(blueprintPath))
			{
				throw new FileNotFoundException("Homestead blueprint not found: " + blueprintPath);
			}
			return HomesteadYaml.Deserialize<ZoneBlueprintFile>(File.ReadAllText(blueprintPath));
		}

		private static ZoneBlueprintFile LoadPlanBlueprint(string name)
		{
			string planGhostBlueprintPath = GetPlanGhostBlueprintPath(name);
			if (File.Exists(planGhostBlueprintPath))
			{
				return HomesteadYaml.Deserialize<ZoneBlueprintFile>(File.ReadAllText(planGhostBlueprintPath));
			}
			return LoadBlueprint(name);
		}

		private static string SaveBlueprint(string name, ZoneBlueprintFile blueprint)
		{
			string blueprintPath = GetBlueprintPath(name);
			Directory.CreateDirectory(Path.GetDirectoryName(blueprintPath));
			File.WriteAllText(blueprintPath, HomesteadYaml.Serialize(blueprint));
			bool iconReady = false;
			try
			{
				iconReady = (Object)(object)ZoneBlueprintVisuals.RenderAndCacheIcon(name, blueprint) != (Object)null;
			}
			catch (Exception ex)
			{
				_logger.LogWarning((object)("Failed to render Homestead blueprint icon '" + name + "' immediately: " + ex.Message));
			}
			ZoneBlueprintSaveToolMenu.RefreshAfterBlueprintSaved(name, blueprint, iconReady);
			return blueprintPath;
		}

		private static ZoneBlueprintFile CloneForName(ZoneBlueprintFile blueprint, string name)
		{
			return new ZoneBlueprintFile
			{
				Version = blueprint.Version,
				Name = name,
				World = blueprint.World,
				SavedAt = blueprint.SavedAt,
				Radius = blueprint.Radius,
				Entries = blueprint.Entries.Select((ZoneBlueprintEntry entry) => new ZoneBlueprintEntry
				{
					SaveId = entry.SaveId,
					Prefab = entry.Prefab,
					LocalPos = entry.LocalPos.ToArray(),
					LocalRot = entry.LocalRot.ToArray(),
					Scale = entry.Scale.ToArray(),
					Data = entry.Data
				}).ToList(),
				TerrainContacts = blueprint.TerrainContacts.Select((ZoneBlueprintTerrainContact contact) => new ZoneBlueprintTerrainContact
				{
					LocalX = contact.LocalX,
					LocalY = contact.LocalY,
					LocalZ = contact.LocalZ
				}).ToList()
			};
		}

		private static string ValidateBlueprintFile(ZoneBlueprintFile blueprint)
		{
			if (blueprint.Entries.Count == 0)
			{
				return HomesteadLocalization.Text("hs_blueprint_no_entries");
			}
			if (!ZoneBlueprintNetworkPayload.TryValidateBlueprintEntryCount(blueprint, upload: true, out string reason))
			{
				return reason;
			}
			if ((Object)(object)ZNetScene.instance == (Object)null)
			{
				return HomesteadLocalization.Text("hs_common_world_not_ready");
			}
			foreach (ZoneBlueprintEntry entry in blueprint.Entries)
			{
				GameObject prefab = ZNetScene.instance.GetPrefab(entry.Prefab);
				if (!Object.op_Implicit((Object)(object)prefab) || (Object)(object)prefab.GetComponent<WearNTear>() == (Object)null || !HasBuildRecipe(prefab))
				{
					return HomesteadLocalization.Format("hs_blueprint_unsupported_prefab", entry.Prefab);
				}
			}
			return "";
		}

		private static string GetUniqueBlueprintName(string preferredName)
		{
			string text = SanitizePathSegment(string.IsNullOrWhiteSpace(preferredName) ? "store_blueprint" : preferredName.Trim());
			string text2 = text;
			int num = 2;
			while (File.Exists(GetBlueprintPath(text2)))
			{
				text2 = $"{text}_{num++}";
			}
			return text2;
		}

		private static string GetUniquePlanGhostBlueprintName(string preferredName)
		{
			string text = SanitizePathSegment(string.IsNullOrWhiteSpace(preferredName) ? "plan_ghost" : preferredName.Trim());
			string text2 = text;
			int num = 2;
			while (File.Exists(GetPlanGhostBlueprintPath(text2)))
			{
				text2 = $"{text}_{num++}";
			}
			return text2;
		}

		private static void EnsureWorldReady()
		{
			if ((Object)(object)ZNet.instance == (Object)null || (Object)(object)ZNetScene.instance == (Object)null || ZDOMan.instance == null || (Object)(object)ZoneSystem.instance == (Object)null)
			{
				throw new InvalidOperationException("World is not ready.");
			}
		}

		private static string GetBlueprintPath(string name)
		{
			return Path.Combine(GetWorldBlueprintDirectory(), SanitizePathSegment(name) + ".hsbp.yml");
		}

		private static string GetPlanGhostBlueprintPath(string name)
		{
			return Path.Combine(GetPlanGhostBlueprintDirectory(), SanitizePathSegment(name) + ".hsbp.yml");
		}

		internal static string GetBlueprintIconPath(string name)
		{
			return Path.Combine(GetWorldBlueprintDirectory(), SanitizePathSegment(name) + ".hsbp.png");
		}

		private static string GetWorldBlueprintDirectory()
		{
			return HomesteadPlugin.BlueprintStorageFullPath;
		}

		private static string GetPlanGhostBlueprintDirectory()
		{
			return HomesteadPlugin.PlanGhostStorageFullPath;
		}

		private static string GetWorldName()
		{
			ZNet instance = ZNet.instance;
			return ((instance != null) ? instance.GetWorldName() : null) ?? "unknown";
		}

		private static string SanitizePathSegment(string value)
		{
			char[] invalidChars = Path.GetInvalidFileNameChars();
			string text = new string(value.Select((char character) => (!invalidChars.Contains(character)) ? character : '_').ToArray()).Trim();
			if (text.Length == 0)
			{
				throw new InvalidOperationException("Blueprint name resolves to an empty path segment.");
			}
			return text;
		}

		private static Vector3 ReadScale(ZDO zdo, GameObject prefab)
		{
			//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)
			return zdo.GetVec3(ZDOVars.s_scaleHash, prefab.transform.localScale);
		}

		private static float[] ToArray(Vector3 value)
		{
			//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_0024: Unknown result type (might be due to invalid IL or missing references)
			return new float[3]
			{
				Round(value.x),
				Round(value.y),
				Round(value.z)
			};
		}

		private static float[] ToArray(Quaternion value)
		{
			//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_0024: 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)
			return new float[4]
			{
				Round(value.x),
				Round(value.y),
				Round(value.z),
				Round(value.w)
			};
		}

		private static Vector3 FromVector(float[] value)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(value[0], value[1], value[2]);
		}

		private static Quaternion FromQuaternion(float[] value)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return new Quaternion(value[0], value[1], value[2], value[3]);
		}

		private static float Round(float value)
		{
			return Mathf.Round(value * 1000f) / 1000f;
		}

		private static float SampleGroundY(float x, float z, float fallbackY)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ZoneSystem.instance == (Object)null)
			{
				return fallbackY;
			}
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(x, fallbackY, z);
			Vector3 val2 = default(Vector3);
			Biome val3 = default(Biome);
			BiomeArea val4 = default(BiomeArea);
			Heightmap val5 = default(Heightmap);
			ZoneSystem.instance.GetGroundData(ref val, ref val2, ref val3, ref val4, ref val5);
			return val.y;
		}
	}
	internal static class ZoneDvergrCirclet
	{
		[HarmonyPatch(typeof(ObjectDB), "Awake")]
		private static class ObjectDbAwakePatch
		{
			private static void Postfix()
			{
				PatchObjectDbItem();
			}
		}

		[HarmonyPatch(typeof(ItemDrop), "Awake")]
		private static class ItemDropAwakePatch
		{
			private static void Postfix(ItemDrop __instance)
			{
				PatchItemData(__instance.m_itemData, initializeDurability: true);
			}
		}

		[HarmonyPatch(typeof(ItemDrop), "Start")]
		private static class ItemDropStartPatch
		{
			private static void Postfix(ItemDrop __instance)
			{
				PatchItemData(__instance.m_itemData, initializeDurability: true);
			}
		}

		[HarmonyPatch(typeof(Inventory), "Load")]
		private static class InventoryLoadPatch
		{
			private static void Postfix(Inventory __instance)
			{
				PatchInventoryItems(__instance);
			}
		}

		[HarmonyPatch(typeof(Inventory), "Changed")]
		private static class InventoryChangedPatch
		{
			private static void Postfix(Inventory __instance)
			{
				PatchInventoryItems(__instance);
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "AttachItem")]
		private static class VisEquipmentAttachItemPatch
		{
			private static void Postfix(VisEquipment __instance, GameObject __result, int itemHash)
			{
				if (Active && Object.op_Implicit((Object)(object)__result) && itemHash == PrefabHash)
				{
					ItemData val = TryGetVisualHelmetItem(__instance);
					ZNetView nview;
					if (val != null)
					{
						PatchItemData(val, initializeDurability: true);
						(__result.GetComponent<ZoneDvergrCircletVisual>() ?? __result.AddComponent<ZoneDvergrCircletVisual>()).Initialize(val);
					}
					else if (TryGetRemoteCircletNview(__instance, out nview) && (Object)(object)nview != (Object)null)
					{
						(__result.GetComponent<ZoneDvergrCircletVisual>() ?? __result.AddComponent<ZoneDvergrCircletVisual>()).InitializeRemote(nview);
					}
				}
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "UpdateEquipmentVisuals")]
		private static class VisEquipmentUpdateEquipmentVisualsPatch
		{
			private static void Postfix(VisEquipment __instance)
			{
				if (ShouldSyncRemoteVisuals() && Object.op_Implicit((Object)(object)__instance) && __instance.m_isPlayer && !IsLocalVisEquipment(__instance) && (Object)(object)((Component)__instance).GetComponent<ZoneDvergrCircletRemoteVisual>() == (Object)null)
				{
					((Component)__instance).gameObject.AddComponent<ZoneDvergrCircletRemoteVisual>().RefreshNow();
				}
			}
		}

		[HarmonyPatch(typeof(Humanoid), "DrainEquipedItemDurability")]
		private static class HumanoidDrainEquipedItemDurabilityPatch
		{
			private static bool Prefix(ItemData item)
			{
				if (Active)
				{
					return !IsDvergrCircletItem(item);
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(Humanoid), "UpdateEquipment")]
		private static class HumanoidUpdateEquipmentPatch
		{
			private static void Postfix(Humanoid __instance, float dt)
			{
				if (!Active)
				{
					return;
				}
				Player val = (Player)(object)((__instance is Player) ? __instance : null);
				if (val == null || (Object)(object)val != (Object)(object)Player.m_localPlayer || !TryGetEquippedDvergrCirclet(val, out ItemData item) || item == null)
				{
					return;
				}
				CircletState circletState = LoadState(item);
				if (PatchItemData(item, initializeDurability: true) && circletState.LightOn && !(item.m_durability <= 0f) && IsCircletLightOn(val, item))
				{
					float durability = item.m_durability;
					item.m_durability = Mathf.Max(0f, item.m_durability - GetDurabilityDrainPerSecond(item) * dt);
					if (Mathf.Abs(durability - item.m_durability) > 0.001f)
					{
						PublishLocalCircletState(val, item, circletState);
					}
					if (durability > 0f && item.m_durability <= 0f)
					{
						((Character)val).Message((MessageType)1, HomesteadLocalization.Text("hs_dvergr_depleted"), 0, item.GetIcon());
						((Humanoid)val).GetInventory().Changed();
					}
				}
			}
		}

		[HarmonyPatch(typeof(Player), "DamageArmorDurability")]
		private static class PlayerDamageArmorDurabilityPatch
		{
			private static void Prefix(Player __instance, ref float __state)
			{
				__state = float.NaN;
				if (TryGetEquippedDvergrCirclet(__instance, out ItemData item) && item != null && Active && PatchItemData(item, initializeDurability: true))
				{
					__state = item.m_durability;
				}
			}

			private static void Postfix(Player __instance, float __state)
			{
				if (!float.IsNaN(__state) && TryGetEquippedDvergrCirclet(__instance, out ItemData item) && item != null && IsDvergrCircletItem(item))
				{
					item.m_durability = Mathf.Clamp(__state, 0f, item.GetMaxDurability());
				}
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "CanRepair")]
		private static class InventoryGuiCanRepairPatch
		{
			private static bool Prefix(ItemData item, ref bool __result)
			{
				if (!Active || !IsDvergrCircletItem(item))
				{
					return true;
				}
				PatchItemData(item, initializeDurability: true);
				Player localPlayer = Player.m_localPlayer;
				if (!Object.op_Implicit((Object)(object)localPlayer) || !item.m_shared.m_canBeReparied)
				{
					__result = false;
					return false;
				}
				if (localPlayer.NoCostCheat())
				{
					__result = true;
					return false;
				}
				CraftingStation currentCraftingStation = localPlayer.GetCurrentCraftingStation();
				__result = MatchesRepairStation(currentCraftingStation);
				return false;
			}
		}

		[HarmonyPatch(typeof(ItemData), "GetTooltip", new Type[]
		{
			typeof(ItemData),
			typeof(int),
			typeof(bool),
			typeof(float),
			typeof(int)
		})]
		private static class ItemDataGetTooltipPatch
		{
			[HarmonyPriority(200)]
			private static void Postfix(ItemData item, bool crafting, ref string __result)
			{
				if (!crafting && Active && PatchItemData(item, initializeDurability: true))
				{
					__result += BuildTooltip(item);
				}
			}
		}

		private sealed class CircletState
		{
			internal bool LightOn = true;

			internal bool HasFuel = true;

			internal float IntensityMultiplier = 1f;

			internal float RangeMultiplier = 1f;
		}

		private sealed class ZoneDvergrCircletVisual : MonoBehaviour
		{
			private readonly List<Light> _lights = new List<Light>();

			private float[] _baseIntensities = Array.Empty<float>();

			private float[] _baseRanges = Array.Empty<float>();

			private bool[] _baseEnabled = Array.Empty<bool>();

			private ItemData? _item;

			private ZNetView? _remoteStateView;

			private bool _remoteCulled;

			internal bool IsFor(ItemData? item)
			{
				if ((Object)(object)_remoteStateView == (Object)null && _item == item)
				{
					return _lights.Count > 0;
				}
				return false;
			}

			internal bool IsRemoteFor(ZNetView nview)
			{
				if ((Object)(object)_remoteStateView == (Object)(object)nview)
				{
					return _lights.Count > 0;
				}
				return false;
			}

			internal void Initialize(ItemData? item)
			{
				_item = item;
				_remoteStateView = null;
				_remoteCulled = false;
				CaptureLights();
				Apply();
			}

			internal void InitializeRemote(ZNetView nview)
			{
				_item = null;
				_remoteStateView = nview;
				_remoteCulled = false;
				CaptureLights();
				Apply();
			}

			internal void SetRemoteCulled(bool culled)
			{
				if (!((Object)(object)_remoteStateView == (Object)null) && _remoteCulled != culled)
				{
					_remoteCulled = culled;
					Apply();
				}
			}

			private void CaptureLights()
			{
				_lights.Clear();
				((Component)this).gameObject.GetComponentsInChildren<Light>(true, _lights);
				_baseIntensities = new float[_lights.Count];
				_baseRanges = new float[_lights.Count];
				_baseEnabled = new bool[_lights.Count];
				for (int i = 0; i < _lights.Count; i++)
				{
					Light val = _lights[i];
					_baseIntensities[i] = (Object.op_Implicit((Object)(object)val) ? val.intensity : 0f);
					_baseRanges[i] = (Object.op_Implicit((Object)(object)val) ? val.range : 0f);
					_baseEnabled[i] = Object.op_Implicit((Object)(object)val) && ((Behaviour)val).enabled;
				}
			}

			internal void ApplyNow()
			{
				Apply();
			}

			private void LateUpdate()
			{
				Apply();
			}

			private void Apply()
			{
				CircletState circletState = (((Object)(object)_remoteStateView != (Object)null) ? LoadRemoteState(_remoteStateView) : LoadState(_item));
				bool flag = Active && !_remoteCulled && circletState.LightOn && circletState.HasFuel;
				float intensityMultiplier = circletState.IntensityMultiplier;
				float rangeMultiplier = circletState.RangeMultiplier;
				for (int i = 0; i < _lights.Count; i++)
				{
					Light val = _lights[i];
					if (Object.op_Implicit((Object)(object)val))
					{
						val.intensity = _baseIntensities[i] * intensityMultiplier;
						val.range = _baseRanges[i] * rangeMultiplier;
						((Behaviour)val).enabled = flag && _baseEnabled[i];
					}
				}
			}
		}

		private sealed class ZoneDvergrCircletRemoteVisual : MonoBehaviour
		{
			private const float RefreshInterval = 0.25f;

			private VisEquipment? _visEquipment;

			private GameObject? _customRoot;

			private float _nextRefreshTime;

			private void Awake()
			{
				_visEquipment = ((Component)this).GetComponent<VisEquipment>();
			}

			private void LateUpdate()
			{
				if (Time.time >= _nextRefreshTime)
				{
					Refresh(force: false);
				}
			}

			private void OnDestroy()
			{
				DestroyCustomRoot();
			}

			internal void RefreshNow()
			{
				Refresh(force: true);
			}

			private void Refresh(bool force)
			{
				if (!force && Time.time < _nextRefreshTime)
				{
					return;
				}
				_nextRefreshTime = Time.time + 0.25f;
				VisEquipment val = (((Object)(object)_visEquipment != (Object)null) ? _visEquipment : (_visEquipment = ((Component)this).GetComponent<VisEquipment>()));
				if (!ShouldSyncRemoteVisuals() || !Object.op_Implicit((Object)(object)val) || !val.m_isPlayer || IsLocalVisEquipment(val) || (Object)(object)val.m_nview == (Object)null || !val.m_nview.IsValid())
				{
					DestroyCustomRoot();
					return;
				}
				ZNetView nview = val.m_nview;
				ZDO zDO = nview.GetZDO();
				if (zDO == null || zDO.GetInt(RemoteItemKey, 0) != PrefabHash)
				{
					CullRemoteVisualComponent(val.m_helmetItemInstance, nview);
					DestroyCustomRoot();
					return;
				}
				bool flag = !IsWithinRemoteLightRange(val);
				if (val.m_currentHelmetItemHash == PrefabHash && Object.op_Implicit((Object)(object)val.m_helmetItemInstance))
				{
					DestroyCustomRoot();
					EnsureRemoteVisualComponent(val.m_helmetItemInstance, nview, flag);
					return;
				}
				CullRemoteVisualComponent(val.m_helmetItemInstance, nview);
				if (flag || !Object.op_Implicit((Object)(object)val.m_helmet))
				{
					DestroyCustomRoot();
					return;
				}
				if (!Object.op_Implicit((Object)(object)_customRoot))
				{
					try
					{
						_customRoot = val.AttachItem(PrefabHash, 0, val.m_helmet, false, false);
						if (Object.op_Implicit((Object)(object)_customRoot))
						{
							((Object)_customRoot).name = "HomesteadDvergrCircletRemoteVisual";
							((Object)_customRoot).hideFlags = (HideFlags)52;
						}
					}
					catch (Exception ex)
					{
						ManualLogSource? logger = _logger;
						if (logger != null)
						{
							logger.LogWarning((object)("Failed to attach remote Dvergr circlet visual; remote light sync skipped for this refresh. " + ex.GetType().Name + ": " + ex.Message));
						}
						DestroyCustomRoot();
						return;
					}
				}
				if (Object.op_Implicit((Object)(object)_customRoot))
				{
					EnsureRemoteVisualComponent(_customRoot, nview, culled: false);
				}
			}

			private void DestroyCustomRoot()
			{
				if (Object.op_Implicit((Object)(object)_customRoot))
				{
					Object.Destroy((Object)(object)_customRoot);
				}
				_customRoot = null;
			}
		}

		private const string PrefabName = "HelmetDverger";

		private const string CircletExtendedGuid = "shudnal.CircletExtended";

		private const string InitKey = "sighsorry.Homestead.dvergr_circlet_initialized";

		private const string StateKey = "sighsorry.Homestead.dvergr_circlet_state";

		private static readonly int RemoteItemKey = StringExtensionMethods.GetStableHashCode("sighsorry.Homestead.dvergr_circlet_item");

		private static readonly int RemoteStateKey = StringExtensionMethods.GetStableHashCode("sighsorry.Homestead.dvergr_circlet_remote_state");

		private static readonly int RemoteStateHashKey = StringExtensionMethods.GetStableHashCode("sighsorry.Homestead.dvergr_circlet_remote_state_hash");

		private static readonly int PrefabHash = StringExtensionMethods.GetStableHashCode("HelmetDverger");

		private static readonly List<Light> TempLights = new List<Light>();

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

		private static ManualLogSource? _logger;

		private static bool _loggedCircletExtendedSkip;

		private static bool? _circletExtendedLoaded;

		private static GameObject? _fallbackLightObject;

		private static Light? _fallbackLight;

		private static ItemData? _fallbackLightItem;

		private static GameObject? _fallbackVisualRoot;

		private static ItemData? _fallbackVisualItem;

		private static float _nextDebugLogTime;

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

		private static bool Active
		{
			get
			{
				if (!DvergrCircletConfig.ExtensionEnabled)
				{
					return false;
				}
				if (!IsCircletExtendedLoaded())
				{
					return true;
				}
				if (!_loggedCircletExtendedSkip)
				{
					_loggedCircletExtendedSkip = true;
					ManualLogSource? logger = _logger;
					if (logger != null)
					{
						logger.LogInfo((object)"Circlet Extended is installed, so Homestead Dvergr circlet handling is disabled to avoid conflicts.");
					}
				}
				return false;
			}
		}

		internal static void Initialize(ManualLogSource logger)
		{
			_logger = logger;
		}

		internal static void ResetForWorldSession()
		{
			Player localPlayer = Player.m_localPlayer;
			if (Object.op_Implicit((Object)(object)localPlayer))
			{
				PublishLocalCircletState(localPlayer, null, null);
			}
			CleanupFallbackVisuals();
			ResetRemoteVisualsForWorldSession();
			TempLights.Clear();
			TempVisualRoots.Clear();
			RepairStationDisplayNameCache.Clear();
			_nextDebugLogTime = 0f;
			_loggedCircletExtendedSkip = false;
			_circletExtendedLoaded = null;
			AzuExtendedPlayerInventoryCompat.ResetForWorldSession();
		}

		internal static void Update()
		{
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			bool active = Active;
			bool flag = ShouldBlockInput();
			Player localPlayer = Player.m_localPlayer;
			ItemData item;
			ItemData val = ((Object.op_Implicit((Object)(object)localPlayer) && TryGetEquippedDvergrCirclet(localPlayer, out item)) ? item : null);
			if (!active)
			{
				if (Object.op_Implicit((Object)(object)localPlayer))
				{
					PublishLocalCircletState(localPlayer, null, null);
				}
				CleanupFallbackVisuals();
				return;
			}
			if (!Object.op_Implicit((Object)(object)localPlayer) || ((Character)localPlayer).IsDead())
			{
				if (Object.op_Implicit((Object)(object)localPlayer))
				{
					PublishLocalCircletState(localPlayer, null, null);
				}
				CleanupFallbackVisuals();
				return;
			}
			if (!PatchItemData(val, initializeDurability: true))
			{
				PublishLocalCircletState(localPlayer, null, null);
				CleanupFallbackVisuals();
				return;
			}
			ItemData item2 = val;
			CircletState circletState = LoadState(item2);
			EnsureLocalCircletVisual(localPlayer, item2, circletState);
			PublishLocalCircletState(localPlayer, item2, circletState);
			LogDebugStatus(localPlayer, item2, circletState);
			if (!flag)
			{
				if (IsShortcutDownLenient(DvergrCircletConfig.ToggleLightHotkey))
				{
					circletState.LightOn = !circletState.LightOn;
					SaveState(item2, circletState);
					((Humanoid)localPlayer).GetInventory().Changed();
					EnsureLocalCircletVisual(localPlayer, item2, circletState);
					PublishLocalCircletState(localPlayer, item2, circletState);
					ShowStateHud(circletState);
				}
				else if (TryAdjustHotkey((KeyCode)273, circletState, 1f, 0f) || TryAdjustHotkey((KeyCode)274, circletState, -1f, 0f) || TryAdjustHotkey((KeyCode)275, circletState, 0f, 1f) || TryAdjustHotkey((KeyCode)276, circletState, 0f, -1f))
				{
					SaveState(item2, circletState);
					((Humanoid)localPlayer).GetInventory().Changed();
					EnsureLocalCircletVisual(localPlayer, item2, circletState);
					PublishLocalCircletState(localPlayer, item2, circletState);
					ShowStateHud(circletState);
				}
			}
		}

		private static bool IsCircletExtendedLoaded()
		{
			if (_circletExtendedLoaded.HasValue)
			{
				return _circletExtendedLoaded.Value;
			}
			_circletExtendedLoaded = Chainloader.PluginInfos.ContainsKey("shudnal.CircletExtended");
			return _circletExtendedLoaded.Value;
		}

		private static bool TryAdjustHotkey(KeyCode arrowKey, CircletState state, float intensityDelta, float rangeDelta)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			if (!Input.GetKeyDown(arrowKey) || !IsAdjustmentModifierHeld())
			{
				return false;
			}
			float perItemAdjustmentStep = DvergrCircletConfig.PerItemAdjustmentStep;
			if (Mathf.Abs(intensityDelta) > 0.001f)
			{
				state.IntensityMultiplier = ClampAndRoundIntensityMultiplier(state.IntensityMultiplier + intensityDelta * perItemAdjustmentStep);
			}
			if (Mathf.Abs(rangeDelta) > 0.001f)
			{
				state.RangeMultiplier = ClampAndRoundRangeMultiplier(state.RangeMultiplier + rangeDelta * perItemAdjustmentStep);
			}
			return true;
		}

		private static bool IsAdjustmentModifierHeld()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: 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_0031: Unknown result type (might be due to invalid IL or missing references)
			KeyboardShortcut adjustmentModifierKey = DvergrCircletConfig.AdjustmentModifierKey;
			if ((int)((KeyboardShortcut)(ref adjustmentModifierKey)).MainKey == 0)
			{
				return true;
			}
			if (!IsShortcutModifierHeld(((KeyboardShortcut)(ref adjustmentModifierKey)).MainKey))
			{
				return false;
			}
			foreach (KeyCode modifier in ((KeyboardShortcut)(ref adjustmentModifierKey)).Modifiers)
			{
				if (!IsShortcutModifierHeld(modifier))
				{
					return false;
				}
			}
			return true;
		}

		private static bool IsShortcutDownLenient(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)
			//IL_0029: 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 false;
			}
			foreach (KeyCode modifier in ((KeyboardShortcut)(ref shortcut)).Modifiers)
			{
				if (!IsShortcutModifierHeld(modifier))
				{
					return false;
				}
			}
			return true;
		}

		private static bool IsShortcutModifierHeld(KeyCode key)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: 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_0027: Expected I4, but got Unknown
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			if ((int)key != 0)
			{
				switch (key - 303)
				{
				case 0:
				case 1:
					return Input.GetKey((KeyCode)304) || Input.GetKey((KeyCode)303);
				case 2:
				case 3:
					return Input.GetKey((KeyCode)306) || Input.GetKey((KeyCode)305);
				case 4:
				case 5:
					return Input.GetKey((KeyCode)308) || Input.GetKey((KeyCode)307);
				default:
					return Input.GetKey(key);
				}
			}
			return true;
		}

		private static bool ShouldBlockInput()
		{
			if (!Hud.IsPieceSelectionVisible() && !Console.IsVisible() && !TextInput.IsVisible() && !Menu.IsVisible() && !InventoryGui.IsVisible())
			{
				return Minimap.IsOpen();
			}
			return true;
		}

		private static bool PatchItemData(ItemData? item, bool initializeDurability)
		{
			if (!Active || item == null || item.m_shared == null || !IsDvergrCircletItem(item))
			{
				return false;
			}
			PatchSharedData(item.m_shared);
			float maxDurability = item.GetMaxDurability();
			if (initializeDurability && !item.m_customData.ContainsKey("sighsorry.Homestead.dvergr_circlet_initialized"))
			{
				item.m_durability = maxDurability;
				item.m_customData["sighsorry.Homestead.dvergr_circlet_initialized"] = "1";
			}
			else
			{
				item.m_durability = Mathf.Clamp(item.m_durability, 0f, maxDurability);
			}
			return true;
		}

		private static void PatchSharedData(SharedData shared)
		{
			shared.m_useDurability = true;
			shared.m_destroyBroken = false;
			shared.m_canBeReparied = true;
			shared.m_maxDurability = 100f;
			shared.m_durabilityPerLevel = 0f;
			shared.m_durabilityDrain = 0f;
			shared.m_useDurabilityDrain = 0f;
		}

		private static void PatchObjectDbItem()
		{
			if (Active && !((Object)(object)ObjectDB.instance == (Object)null))
			{
				GameObject itemPrefab = ObjectDB.instance.GetItemPrefab("HelmetDverger");
				if (Object.op_Implicit((Object)(object)itemPrefab))
				{
					PatchItemData(itemPrefab.GetComponent<ItemDrop>()?.m_itemData, initializeDurability: false);
				}
			}
		}

		private static void PatchInventoryItems(Inventory? inventory)
		{
			if (!Active || inventory == null)
			{
				return;
			}
			foreach (ItemData allItem in inventory.GetAllItems())
			{
				PatchItemData(allItem, initializeDurability: true);
			}
		}

		private static float GetDurabilityDrainPerSecond()
		{
			return 100f / DvergrCircletConfig.FuelSeconds;
		}

		private static float GetDurabilityDrainPerSecond(ItemData item)
		{
			CircletState circletState = LoadState(item);
			return GetDurabilityDrainPerSecond() * circletState.IntensityMultiplier * circletState.RangeMultiplier;
		}

		private static bool MatchesRepairStation(CraftingStation? station)
		{
			if (!Object.op_Implicit((Object)(object)station))
			{
				return false;
			}
			string text = NormalizeStationName(DvergrCircletConfig.RepairStation);
			if (text.Length == 0)
			{
				return true;
			}
			if (!(NormalizeStationName(station.m_name) == text) && !(NormalizeStationName(((Object)((Component)station).gameObject).name) == text))
			{
				return NormalizeStationName(Utils.GetPrefabName(((Object)((Component)station).gameObject).name)) == text;
			}
			return true;
		}

		private static string NormalizeStationName(string value)
		{
			string text = (value ?? string.Empty).Trim();
			if (text.EndsWith("(Clone)", StringComparison.OrdinalIgnoreCase))
			{
				text = text.Substring(0, text.Length - 7).Trim();
			}
			text = text.ToLowerInvariant();
			if (text.StartsWith("$piece_", StringComparison.OrdinalIgnoreCase))
			{
				text = text.Substring(7);
			}
			else if (text.StartsWith("piece_", StringComparison.OrdinalIgnoreCase))
			{
				text = text.Substring(6);
			}
			return text.Replace(" ", "").Replace("_", "");
		}

		private static void ShowStateHud(CircletState state)
		{
			ZoneAreaToolStatusHud.ShowDvergrCirclet(state.LightOn, state.IntensityMultiplier, state.RangeMultiplier);
		}

		private static string BuildTooltip(ItemData item)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			CircletState circletState = LoadState(item);
			string text = (circletState.LightOn ? "$hud_on" : "$hud_off");
			return "\n\n<color=orange>" + HomesteadLocalization.Text("hs_dvergr_title") + "</color>\n" + HomesteadLocalization.Format("hs_dvergr_tooltip_light", text, FormatShortcut(DvergrCircletConfig.ToggleLightHotkey)) + "\n" + HomesteadLocalization.Format("hs_dvergr_tooltip_intensity", circletState.IntensityMultiplier * 100f, FormatAdjustmentShortcutPair("↑ ↓")) + "\n" + HomesteadLocalization.Format("hs_dvergr_tooltip_range", circletState.RangeMultiplier * 100f, FormatAdjustmentShortcutPair("← →")) + "\n" + HomesteadLocalization.Format("hs_dvergr_tooltip_repair_station", GetRepairStationDisplayName());
		}

		private static string GetRepairStationDisplayName()
		{
			string text = DvergrCircletConfig.RepairStation;
			if (string.IsNullOrWhiteSpace(text))
			{
				text = "forge";
			}
			if (RepairStationDisplayNameCache.TryGetValue(text, out string value))
			{
				return value;
			}
			string text2 = ResolveRepairStationDisplayName(text);
			RepairStationDisplayNameCache[text] = text2;
			return text2;
		}

		private static string ResolveRepairStationDisplayName(string configured)
		{
			string text = configured.Trim();
			GameObject val = FindCraftingStationPrefab(text);
			if ((Object)(object)val != (Object)null)
			{
				Piece component = val.GetComponent<Piece>();
				if ((Object)(object)component != (Object)null && !string.IsNullOrWhiteSpace(component.m_name))
				{
					Localization instance = Localization.instance;
					string text2 = ((instance != null) ? instance.Localize(component.m_name) : null) ?? "";
					if (!string.IsNullOrWhiteSpace(text2) && !string.Equals(text2, component.m_name, StringComparison.Ordinal))
					{
						return text2;
					}
					string text3 = StripLocalizationToken(component.m_name);
					if (!string.IsNullOrWhiteSpace(text3))
					{
						return text3;
					}
				}
			}
			if (text.StartsWith("$", StringComparison.Ordinal))
			{
				Localization instance2 = Localization.instance;
				string text4 = ((instance2 != null) ? instance2.Localize(text) : null) ?? "";
				if (!string.IsNullOrWhiteSpace(text4) && !string.Equals(text4, text, StringComparison.Ordinal))
				{
					return text4;
				}
				string text5 = StripLocalizationToken(text);
				if (!string.IsNullOrWhiteSpace(text5))
				{
					return text5;
				}
			}
			return text;
		}

		private static GameObject? FindCraftingStationPrefab(string configured)
		{
			string text = NormalizeStationName(configured);
			if (text.Length == 0)
			{
				return null;
			}
			GameObject[] array = new GameObject[4];
			ZNetScene instance = ZNetScene.instance;
			array[0] = ((instance != null) ? instance.GetPrefab(configured) : null);
			ZNetScene instance2 = ZNetScene.instance;
			array[1] = ((instance2 != null) ? instance2.GetPrefab(Utils.GetPrefabName(configured)) : null);
			array[2] = PrefabManager.Instance.GetPrefab(configured);
			array[3] = PrefabManager.Instance.GetPrefab(Utils.GetPrefabName(configured));
			GameObject[] array2 = (GameObject[])(object)array;
			foreach (GameObject val in array2)
			{
				if (IsMatchingCraftingStation(val, text))
				{
					return val;
				}
			}
			if ((Object)(object)ZNetScene.instance != (Object)null)
			{
				foreach (GameObject prefab in ZNetScene.instance.m_prefabs)
				{
					if (IsMatchingCraftingStation(prefab, text))
					{
						return prefab;
					}
				}
			}
			return null;
		}

		private static bool IsMatchingCraftingStation(GameObject? prefab, string wanted)
		{
			if (!Object.op_Implicit((Object)(object)prefab) || (Object)(object)prefab.GetComponent<CraftingStation>() == (Object)null)
			{
				return false;
			}
			Piece component = prefab.GetComponent<Piece>();
			if (!(NormalizeStationName(((Object)prefab).name) == wanted) && !(NormalizeStationName(Utils.GetPrefabName(((Object)prefab).name)) == wanted))
			{
				if ((Object)(object)component != (Object)null)
				{
					return NormalizeStationName(component.m_name) == wanted;
				}
				return false;
			}
			return true;
		}

		private static string StripLocalizationToken(string value)
		{
			string text = (value ?? string.Empty).Trim();
			if (text.StartsWith("$piece_", StringComparison.OrdinalIgnoreCase))
			{
				text = text.Substring(7);
			}
			else if (text.StartsWith("$item_", StringComparison.OrdinalIgnoreCase))
			{
				text = text.Substring(6);
			}
			else if (text.StartsWith("$", StringComparison.Ordinal))
			{
				text = text.Substring(1);
			}
			text = text.Replace("_", " ").Trim();
			if (text.Length != 0)
			{
				return CultureInfo.InvariantCulture.TextInfo.ToTitleCase(text);
			}
			return value ?? string.Empty;
		}

		private static string FormatShortcut(KeyboardShortcut shortcut)
		{
			string text = ((object)(KeyboardShortcut)(ref shortcut)).ToString();
			if (!string.IsNullOrWhiteSpace(text))
			{
				return text.Replace(" + ", "+");
			}
			return "Unbound";
		}

		private static string FormatAdjustmentShortcutPair(string arrows)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: 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)
			KeyboardShortcut adjustmentModifierKey = DvergrCircletConfig.AdjustmentModifierKey;
			if ((int)((KeyboardShortcut)(ref adjustmentModifierKey)).MainKey == 0)
			{
				return arrows;
			}
			return FormatShortcut(adjustmentModifierKey) + " + " + arrows;
		}

		internal static bool IsDvergrCircletItem(ItemData? item)
		{
			if (item == null)
			{
				return false;
			}
			string text = (Object.op_Implicit((Object)(object)item.m_dropPrefab) ? ((Object)item.m_dropPrefab).name : string.Empty);
			if (text.Equals("HelmetDverger", StringComparison.OrdinalIgnoreCase) || text.StartsWith("HelmetDverger", StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			string text2 = item.m_shared?.m_name ?? string.Empty;
			if (text2.IndexOf("helmet_dverger", StringComparison.OrdinalIgnoreCase) < 0)
			{
				if (text2.IndexOf("dverger", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					if (text2.IndexOf("helmet", StringComparison.OrdinalIgnoreCase) < 0)
					{
						return text2.IndexOf("circlet", StringComparison.OrdinalIgnoreCase) >= 0;
					}
					return true;
				}
				return false;
			}
			return true;
		}

		internal static bool TryGetEquippedDvergrCirclet(Player player, out ItemData? item)
		{
			item = null;
			if (!Object.op_Implicit((Object)(object)player))
			{
				return false;
			}
			if (IsDvergrCircletItem(((Humanoid)player).m_helmetItem))
			{
				item = ((Humanoid)player).m_helmetItem;
				return true;
			}
			return AzuExtendedPlayerInventoryCompat.TryGetCustomEquippedItem(player, IsDvergrCircletItem, out item);
		}

		private static ItemData? TryGetVisualHelmetItem(VisEquipment visEquipment)
		{
			Player localPlayer = Player.m_localPlayer;
			if (Object.op_Implicit((Object)(object)localPlayer) && (Object)(object)((Humanoid)localPlayer).m_visEquipment == (Object)(object)visEquipment && TryGetEquippedDvergrCirclet(localPlayer, out ItemData item))
			{
				return item;
			}
			Player componentInParent = ((Component)visEquipment).GetComponentInParent<Player>();
			if (Object.op_Implicit((Object)(object)componentInParent) && TryGetEquippedDvergrCirclet(componentInParent, out ItemData item2))
			{
				return item2;
			}
			return null;
		}

		private static bool IsCircletLightOn(Player player, ItemData item)
		{
			TempLights.Clear();
			CollectCircletLights(player, item, TempLights);
			foreach (Light tempLight in TempLights)
			{
				if (Object.op_Implicit((Object)(object)tempLight) && ((Behaviour)tempLight).enabled && ((Component)tempLight).gameObject.activeInHierarchy)
				{
					return true;
				}
			}
			return false;
		}

		internal static bool TryAppendFallbackLight(List<Light> output)
		{
			int count = output.Count;
			if ((Object)(object)_fallbackVisualRoot != (Object)null && Object.op_Implicit((Object)(object)_fallbackVisualRoot) && _fallbackVisualRoot.activeInHierarchy)
			{
				_fallbackVisualRoot.GetComponentsInChildren<Light>(true, output);
			}
			if ((Object)(object)_fallbackLight == (Object)null || !Object.op_Implicit((Object)(object)_fallbackLight) || !((Behaviour)_fallbackLight).enabled || !((Component)_fallbackLight).gameObject.activeInHierarchy)
			{
				return output.Count > count;
			}
			output.Add(_fallbackLight);
			return output.Count > count;
		}

		private static void CollectCircletLights(Player player, ItemData item, List<Light> output)
		{
			VisEquipment visEquipment = ((Humanoid)player).m_visEquipment;
			if (!Object.op_Implicit((Object)(object)visEquipment))
			{
				CleanupFallbackVisuals();
				return;
			}
			if (item == ((Humanoid)player).m_helmetItem && Object.op_Implicit((Object)(object)visEquipment.m_helmetItemInstance))
			{
				visEquipment.m_helmetItemInstance.GetComponentsInChildren<Light>(true, output);
			}
			if (AzuExtendedPlayerInventoryCompat.TryGetCustomEquipVisualRoots(visEquipment, item, TempVisualRoots))
			{
				foreach (GameObject tempVisualRoot in TempVisualRoots)
				{
					if (Object.op_Implicit((Object)(object)tempVisualRoot))
					{
						tempVisualRoot.GetComponentsInChildren<Light>(true, output);
					}
				}
			}
			TryAppendFallbackLight(output);
		}

		private static void EnsureLocalCircletVisual(Player player, ItemData item, CircletState state)
		{
			VisEquipment visEquipment = ((Humanoid)player).m_visEquipment;
			if (!Object.op_Implicit((Object)(object)visEquipment))
			{
				return;
			}
			int num = 0;
			if (item == ((Humanoid)player).m_helmetItem && Object.op_Implicit((Object)(object)visEquipment.m_helmetItemInstance))
			{
				EnsureVisualComponent(visEquipment.m_helmetItemInstance, item);
				num++;
			}
			if (AzuExtendedPlayerInventoryCompat.TryGetCustomEquipVisualRoots(visEquipment, item, TempVisualRoots))
			{
				foreach (GameObject tempVisualRoot in TempVisualRoots)
				{
					if (Object.op_Implicit((Object)(object)tempVisualRoot))
					{
						EnsureVisualComponent(tempVisualRoot, item);
						num++;
					}
				}
			}
			TempLights.Clear();
			CollectCircletLights(player, item, TempLights);
			bool flag = TempLights.Any((Light light) => Object.op_Implicit((Object)(object)light) && (Object)(object)light != (Object)(object)_fallbackLight);
			if (num == 0 || !flag)
			{
				if (EnsureFallbackVisual(player, item))
				{
					TempLights.Clear();
					CollectCircletLights(player, item, TempLights);
					if (TempLights.Any((Light light) => Object.op_Implicit((Object)(object)light) && (Object)(object)light != (Object)(object)_fallbackLight))
					{
						DisableFallbackLight();
						return;
					}
				}
				UpdateFallbackLight(player, item, state);
			}
			else
			{
				DestroyFallbackVisual();
				DisableFallbackLight();
			}
		}

		private static void EnsureVisualComponent(GameObject root, ItemData item)
		{
			ZoneDvergrCircletVisual zoneDvergrCircletVisual = root.GetComponent<ZoneDvergrCircletVisual>() ?? root.AddComponent<ZoneDvergrCircletVisual>();
			if (!zoneDvergrCircletVisual.IsFor(item))
			{
				zoneDvergrCircletVisual.Initialize(item);
			}
			zoneDvergrCircletVisual.ApplyNow();
		}

		private static void UpdateFallbackLight(Player player, ItemData item, CircletState state)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0068: 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)
			//IL_008c: 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)
			EnsureFallbackLight();
			if (!((Object)(object)_fallbackLight == (Object)null) && !((Object)(object)_fallbackLightObject == (Object)null))
			{
				_fallbackLightItem = item;
				Transform val = ((Component)player).transform;
				if (TryGetHelmetTransform(player, out Transform helmetTransform) && (Object)(object)helmetTransform != (Object)null)
				{
					val = helmetTransform;
				}
				_fallbackLightObject.transform.position = val.position + val.up * 0.05f + val.forward * 0.28f;
				_fallbackLightObject.transform.rotation = val.rotation;
				_fallbackLight.type = (LightType)2;
				_fallbackLight.color = new Color(1f, 0.82f, 0.58f, 1f);
				_fallbackLight.intensity = 1.25f * state.IntensityMultiplier;
				_fallbackLight.range = 14f * state.RangeMultiplier;
				_fallbackLight.shadows = (LightShadows)2;
				((Behaviour)_fallbackLight).enabled = Active && state.LightOn && item.m_durability > 0f;
				_fallbackLightObject.SetActive(((Behaviour)_fallbackLight).enabled);
			}
		}

		private static void EnsureFallbackLight()
		{
			//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)
			//IL_004a: Expected O, but got Unknown
			if (!((Object)(object)_fallbackLightObject != (Object)null) || !Object.op_Implicit((Object)(object)_fallbackLightObject) || !((Object)(object)_fallbackLight != (Object)null) || !Object.op_Implicit((Object)(object)_fallbackLight))
			{
				_fallbackLightObject = new GameObject("HomesteadDvergrCircletFallbackLight")
				{
					hideFlags = (HideFlags)61
				};
				_fallbackLight = _fallbackLightObject.AddComponent<Light>();
				_fallbackLightObject.SetActive(false);
			}
		}

		private static void DisableFallbackLight()
		{
			_fallbackLightItem = null;
			if ((Object)(object)_fallbackLight != (Object)null && Object.op_Implicit((Object)(object)_fallbackLight))
			{
				((Behaviour)_fallbackLight).enabled = false;
			}
			if ((Object)(object)_fallbackLightObject != (Object)null && Object.op_Implicit((Object)(object)_fallbackLightObject))
			{
				_fallbackLightObject.SetActive(false);
			}
		}

		private static bool EnsureFallbackVisual(Player player, ItemData item)
		{
			if (!TryGetHelmetTransform(player, out Transform helmetTransform) || (Object)(object)helmetTransform == (Object)null)
			{
				return false;
			}
			if ((Object)(object)_fallbackVisualRoot != (Object)null && Object.op_Implicit((Object)(object)_fallbackVisualRoot) && _fallbackVisualItem == item)
			{
				_fallbackVisualRoot.SetActive(true);
				EnsureVisualComponent(_fallbackVisualRoot, item);
				return true;
			}
			DestroyFallbackVisual();
			try
			{
				GameObject val = ((Humanoid)player).m_visEquipment.AttachItem(PrefabHash, 0, helmetTransform, false, false);
				if (!Object.op_Implicit((Object)(object)val))
				{
					return false;
				}
				((Object)val).name = "HomesteadDvergrCircletFallbackVisual";
				((Object)val).hideFlags = (HideFlags)52;
				_fallbackVisualRoot = val;
				_fallbackVisualItem = item;
				EnsureVisualComponent(val, item);
				return true;
			}
			catch (Exception ex)
			{
				ManualLogSource? logger = _logger;
				if (logger != null)
				{
					logger.LogWarning((object)("Failed to attach fallback Dvergr circlet visual to helmet joint; using point light fallback. " + ex.GetType().Name + ": " + ex.Message));
				}
				DestroyFallbackVisual();
				return false;
			}
		}

		private static bool TryGetHelmetTransform(Player player, out Transform? helmetTransform)
		{
			helmetTransform = null;
			VisEquipment visEquipment = ((Humanoid)player).m_visEquipment;
			if (!Object.op_Implicit((Object)(object)visEquipment) || !Object.op_Implicit((Object)(object)visEquipment.m_helmet))
			{
				return false;
			}
			helmetTransform = visEquipment.m_helmet;
			return true;
		}

		private static void CleanupFallbackVisuals()
		{
			DestroyFallbackVisual();
			DisableFallbackLight();
		}

		private static void DestroyFallbackVisual()
		{
			_fallbackVisualItem = null;
			if ((Object)(object)_fallbackVisualRoot != (Object)null && Object.op_Implicit((Object)(object)_fallbackVisualRoot))
			{
				Object.Destroy((Object)(object)_fallbackVisualRoot);
			}
			_fallbackVisualRoot = null;
		}

		private static void LogDebugStatus(Player player, ItemData item, CircletState state)
		{
			if (!DvergrCircletConfig.DebugLogging || Time.time < _nextDebugLogTime)
			{
				return;
			}
			_nextDebugLogTime = Time.time + 5f;
			bool flag = item == ((Humanoid)player).m_helmetItem;
			bool flag2 = !flag && AzuExtendedPlayerInventoryCompat.IsLoaded;
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			VisEquipment visEquipment = ((Humanoid)player).m_visEquipment;
			if (Object.op_Implicit((Object)(object)visEquipment))
			{
				if (flag && Object.op_Implicit((Object)(object)visEquipment.m_helmetItemInstance))
				{
					num++;
					TempLights.Clear();
					visEquipment.m_helmetItemInstance.GetComponentsInChildren<Light>(true, TempLights);
					num2 += TempLights.Count;
				}
				if (AzuExtendedPlayerInventoryCompat.TryGetCustomEquipVisualRoots(visEquipment, item, TempVisualRoots))
				{
					num += TempVisualRoots.Count;
					foreach (GameObject tempVisualRoot in TempVisualRoots)
					{
						if (Object.op_Implicit((Object)(object)tempVisualRoot))
						{
							TempLights.Clear();
							tempVisualRoot.GetComponentsInChildren<Light>(true, TempLights);
							num2 += TempLights.Count;
						}
					}
				}
			}
			if ((Object)(object)_fallbackVisualRoot != (Object)null && Object.op_Implicit((Object)(object)_fallbackVisualRoot))
			{
				TempLights.Clear();
				_fallbackVisualRoot.GetComponentsInChildren<Light>(true, TempLights);
				num3 = TempLights.Count;
			}
			GameObject dropPrefab = item.m_dropPrefab;
			string text = ((dropPrefab != null) ? ((Object)dropPrefab).name : null) ?? item.m_shared?.m_name ?? "unknown";
			ManualLogSource? logger = _logger;
			if (logger != null)
			{
				logger.LogInfo((object)$"Dvergr circlet debug: item={text}, vanillaHelmet={flag}, azuLoaded={AzuExtendedPlayerInventoryCompat.IsLoaded}, azuCustomEquipped={flag2}, visualRoots={num}, visualLights={num2}, fallbackVisualActive={(Object)(object)_fallbackVisualRoot != (Object)null && _fallbackVisualRoot.activeInHierarchy}, fallbackVisualLights={num3}, fallbackPointActive={(Object)(object)_fallbackLightObject != (Object)null && _fallbackLightObject.activeSelf}, lightOn={state.LightOn}, durability={item.m_durability:0.0}/{item.GetMaxDurability():0.0}, intensity={state.IntensityMultiplier:0.##}, range={state.RangeMultiplier:0.##}");
			}
		}

		private static void PublishLocalCircletState(Player player, ItemData? item, CircletState? state)
		{
			if (!Object.op_Implicit((Object)(object)player) || (Object)(object)((Character)player).m_nview == (Object)null || !((Character)player).m_nview.IsValid() || !((Character)player).m_nview.IsOwner())
			{
				return;
			}
			ZDO zDO = ((Character)player).m_nview.GetZDO();
			if (zDO != null)
			{
				if (!Active || !DvergrCircletConfig.RemoteVisualSync || item == null || !IsDvergrCircletItem(item))
				{
					SetRemoteCircletZdo(zDO, 0, "");
					return;
				}
				string serializedState = SerializeState(state ?? LoadState(item), item.m_durability > 0f, includeFuel: true);
				SetRemoteCircletZdo(zDO, PrefabHash, serializedState);
			}
		}

		private static void SetRemoteCircletZdo(ZDO zdo, int itemHash, string serializedState)
		{
			int num = ((!string.IsNullOrEmpty(serializedState)) ? StringExtensionMethods.GetStableHashCode(serializedState) : 0);
			if (zdo.GetInt(RemoteItemKey, 0) != itemHash)
			{
				zdo.Set(RemoteItemKey, itemHash, false);
			}
			if (zdo.GetString(RemoteStateKey, "") != serializedState)
			{
				zdo.Set(RemoteStateKey, serializedState);
			}
			if (zdo.GetInt(RemoteStateHashKey, 0) != num)
			{
				zdo.Set(RemoteStateHashKey, num, false);
			}
		}

		private static bool ShouldSyncRemoteVisuals()
		{
			if (Active)
			{
				return DvergrCircletConfig.RemoteVisualSync;
			}
			return false;
		}

		private static bool IsLocalVisEquipment(VisEquipment visEquipment)
		{
			Player localPlayer = Player.m_localPlayer;
			if (Object.op_Implicit((Object)(object)localPlayer))
			{
				return (Object)(object)((Humanoid)localPlayer).m_visEquipment == (Object)(object)visEquipment;
			}
			return false;
		}

		private static bool IsWithinRemoteLightRange(VisEquipment visEquipment)
		{
			//IL_0026: 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)
			float remoteLightMaxDistance = DvergrCircletConfig.RemoteLightMaxDistance;
			if (remoteLightMaxDistance <= 0f)
			{
				return true;
			}
			Player localPlayer = Player.m_localPlayer;
			if (!Object.op_Implicit((Object)(object)localPlayer))
			{
				return true;
			}
			Vector3 val = ((Component)visEquipment).transform.position - ((Component)localPlayer).transform.position;
			return ((Vector3)(ref val)).sqrMagnitude <= remoteLightMaxDistance * remoteLightMaxDistance;
		}

		private static void EnsureRemoteVisualComponent(GameObject root, ZNetView nview, bool culled)
		{
			ZoneDvergrCircletVisual zoneDvergrCircletVisual = root.GetComponent<ZoneDvergrCircletVisual>() ?? root.AddComponent<ZoneDvergrCircletVisual>();
			if (!zoneDvergrCircletVisual.IsRemoteFor(nview))
			{
				zoneDvergrCircletVisual.InitializeRemote(nview);
			}
			zoneDvergrCircletVisual.SetRemoteCulled(culled);
			zoneDvergrCircletVisual.ApplyNow();
		}

		private static bool TryGetRemoteCircletNview(VisEquipment visEquipment, out ZNetView? nview)
		{
			nview = null;
			if (!ShouldSyncRemoteVisuals() || !Object.op_Implicit((Object)(object)visEquipment) || !visEquipment.m_isPlayer || IsLocalVisEquipment(visEquipment) || (Object)(object)visEquipment.m_nview == (Object)null || !visEquipment.m_nview.IsValid())
			{
				return false;
			}
			ZDO zDO = visEquipment.m_nview.GetZDO();
			if (zDO == null || zDO.GetInt(RemoteItemKey, 0) != PrefabHash)
			{
				return false;
			}
			nview = visEquipment.m_nview;
			return true;
		}

		private static void CullRemoteVisualComponent(GameObject? root, ZNetView? nview)
		{
			if (Object.op_Implicit((Object)(object)root) && !((Object)(object)nview == (Object)null))
			{
				ZoneDvergrCircletVisual component = root.GetComponent<ZoneDvergrCircletVisual>();
				if ((Object)(object)component != (Object)null && component.IsRemoteFor(nview))
				{
					component.SetRemoteCulled(culled: true);
				}
			}
		}

		private static CircletState LoadState(ItemData? item)
		{
			if (item == null || !item.m_customData.TryGetValue("sighsorry.Homestead.dvergr_circlet_state", out var value))
			{
				return new CircletState();
			}
			CircletState circletState = LoadStateFromString(value);
			circletState.HasFuel = item.m_durability > 0f;
			return circletState;
		}

		private static CircletState LoadRemoteState(ZNetView? nview)
		{
			if ((Object)(object)nview == (Object)null || !nview.IsValid())
			{
				return new CircletState
				{
					HasFuel = false
				};
			}
			ZDO zDO = nview.GetZDO();
			if (zDO == null || zDO.GetInt(RemoteItemKey, 0) != PrefabHash)
			{
				return new CircletState
				{
					HasFuel = false
				};
			}
			return LoadStateFromString(zDO.GetString(RemoteStateKey, ""));
		}

		private static CircletState LoadStateFromString(string? serialized)
		{
			CircletState circletState = new CircletState();
			if (serialized == null)
			{
				return circletState;
			}
			if (string.IsNullOrWhiteSpace(serialized))
			{
				return circletState;
			}
			string[] array = serialized.Split(new char[1] { ';' });
			for (int i = 0; i < array.Length; i++)
			{
				string[] array2 = array[i].Split(new char[1] { '=' }, 2);
				if (array2.Length == 2)
				{
					string text = array2[0].Trim();
					string text2 = array2[1].Trim();
					float result;
					float result2;
					if (text.Equals("on", StringComparison.OrdinalIgnoreCase))
					{
						circletState.LightOn = text2 == "1" || text2.Equals("true", StringComparison.OrdinalIgnoreCase);
					}
					else if (text.Equals("intensity", StringComparison.OrdinalIgnoreCase) && float.TryParse(text2, NumberStyles.Float, CultureInfo.InvariantCulture, out result))
					{
						circletState.IntensityMultiplier = ClampAndRoundIntensityMultiplier(result);
					}
					else if (text.Equals("range", StringComparison.OrdinalIgnoreCase) && float.TryParse(text2, NumberStyles.Float, CultureInfo.InvariantCulture, out result2))
					{
						circletState.RangeMultiplier = ClampAndRoundRangeMultiplier(result2);
					}
					else if ((text.Equals("fuel", StringComparison.OrdinalIgnoreCase) || text.Equals("active", StringComparison.OrdinalIgnoreCase)) && (text2 == "0" || text2.Equals("false", StringComparison.OrdinalIgnoreCase)))
					{
						circletState.HasFuel = false;
					}
				}
			}
			return circletState;
		}

		private static void SaveState(ItemData item, CircletState state)
		{
			state.IntensityMultiplier = ClampAndRoundIntensityMultiplier(state.IntensityMultiplier);
			state.RangeMultiplier = ClampAndRoundRangeMultiplier(state.RangeMultiplier);
			item.m_customData["sighsorry.Homestead.dvergr_circlet_state"] = SerializeState(state, hasFuel: true, includeFuel: false);
		}

		private static string SerializeState(CircletState state, bool hasFuel, bool includeFuel)
		{
			state.IntensityMultiplier = ClampAndRoundIntensityMultiplier(state.IntensityMultiplier);
			state.RangeMultiplier = ClampAndRoundRangeMultiplier(state.RangeMultiplier);
			string text = string.Format("on={0};intensity={1};range={2}", state.LightOn ? 1 : 0, state.IntensityMultiplier.ToString("0.##", CultureInfo.InvariantCulture), state.RangeMultiplier.ToString("0.##", CultureInfo.InvariantCulture));
			if (includeFuel)
			{
				text += $";fuel={(hasFuel ? 1 : 0)}";
			}
			return text;
		}

		private static float ClampAndRoundIntensityMultiplier(float value)
		{
			return ClampAndRoundMultiplier(value, DvergrCircletConfig.PerItemMaxIntensityMultiplier);
		}

		private static float ClampAndRoundRangeMultiplier(float value)
		{
			return ClampAndRoundMultiplier(value, DvergrCircletConfig.PerItemMaxRangeMultiplier);
		}

		private static float ClampAndRoundMultiplier(float value, float maxMultiplier)
		{
			float perItemAdjustmentStep = DvergrCircletConfig.PerItemAdjustmentStep;
			return Mathf.Clamp((perItemAdjustmentStep > 0f) ? (Mathf.Round(value / perItemAdjustmentStep) * perItemAdjustmentStep) : value, 1f, maxMultiplier);
		}

		private static void ResetRemoteVisualsForWorldSession()
		{
			ZoneDvergrCircletRemoteVisual[] array = Object.FindObjectsByType<ZoneDvergrCircletRemoteVisual>((FindObjectsSortMode)0);
			foreach (ZoneDvergrCircletRemoteVisual zoneDvergrCircletRemoteVisual in array)
			{
				if (Object.op_Implicit((Object)(object)zoneDvergrCircletRemoteVisual))
				{
					Object.Destroy((Object)(object)zoneDvergrCircletRemoteVisual);
				}
			}
			ZoneDvergrCircletVisual[] array2 = Object.FindObjectsByType<ZoneDvergrCircletVisual>((FindObjectsSortMode)0);
			foreach (ZoneDvergrCircletVisual zoneDvergrCircletVisual in array2)
			{
				if (Object.op_Implicit((Object)(object)zoneDvergrCircletVisual))
				{
					Object.Destroy((Object)(object)zoneDvergrCircletVisual);
				}
			}
		}
	}
	internal sealed class ZoneBlueprintFile
	{
		public int Version { get; set; } = 1;


		public string Name { get; set; } = "";


		public string World { get; set; } = "";


		public string SavedAt { get; set; } = "";


		public float Radius { get; set; }

		public List<ZoneBlueprintEntry> Entries { get; set; } = new List<ZoneBlueprintEntry>();


		public List<ZoneBlueprintTerrainContact> TerrainContacts { get; set; } = new List<ZoneBlueprintTerrainContact>();

	}
	internal sealed class ZoneBlueprintEntry
	{
		public string SaveId { get; set; } = "";


		public string Prefab { get; set; } = "";


		public float[] LocalPos { get; set; } = new float[3];


		public float[] LocalRot { get; set; } = new float[4];


		public float[] Scale { get; set; } = new float[3];


		public string Data { get; set; } = "";

	}
	internal sealed class ZoneBlueprintTerrainContact
	{
		public float LocalX { get; set; }

		public float LocalY { get; set; }

		public float LocalZ { get; set; }
	}
	internal sealed class ZoneBlueprintRequirement
	{
		public string ItemName { get; set; } = "";


		public string PrefabName { get; set; } = "";


		public string DisplayName { get; set; } = "";


		public int Amount { get; set; }
	}
	internal sealed class ZoneBlueprintCraftingStationRequirement
	{
		public string StationName { get; set; } = "";


		public string PrefabName { get; set; } = "";


		public string DisplayName { get; set; } = "";

	}
	internal sealed class ZoneBlueprintStoreCatalog
	{
		public int Version { get; set; } = 1;


		public List<ZoneBlueprintStoreListing> Listings { get; set; } = new List<ZoneBlueprintStoreListing>();


		public List<ZoneBlueprintStoreOffer> Offers { get; set; } = new List<ZoneBlueprintStoreOffer>();


		public List<ZoneBlueprintStoreNotification> Notifications { get; set; } = new List<ZoneBlueprintStoreNotification>();


		public List<ZoneBlueprintStoreBalance> Balances { get; set; } = new List<ZoneBlueprintStoreBalance>();

	}
	internal sealed class ZoneBlueprintStoreListing
	{
		public string ListingId { get; set; } = "";


		public string Name { get; set; } = "";


		public string SellerName { get; set; } = "";


		public long SellerPlayerId { get; set; }

		public string SellerPlatformId { get; set; } = "";


		public string CreatedAt { get; set; } = "";


		public string ExpiresAt { get; set; } = "";


		public List<ZoneBlueprintStorePriceItem> PriceItems { get; set; } = new List<ZoneBlueprintStorePriceItem>();


		public int EntryCount { get; set; }

		public int PurchaseCount { get; set; }

		public string BlueprintFile { get; set; } = "";


		public string IconPngBase64 { get; set; } = "";


		public bool Active { get; set; } = true;

	}
	internal sealed class ZoneBlueprintStoreBalance
	{
		public long SellerPlayerId { get; set; }

		public string SellerPlatformId { get; set; } = "";


		public string SellerName { get; set; } = "";


		public int Coins { get; set; }

		public List<ZoneBlueprintStorePriceItem> Materials { get; set; } = new List<ZoneBlueprintStorePriceItem>();

	}
	internal sealed class ZoneBlueprintStoreOffer
	{
		public string OfferId { get; set; } = "";


		public string ListingId { get; set; } = "";


		public string BuyerName { get; set; } = "";


		public long BuyerPlayerId { get; set; }

		public string BuyerPlatformId { get; set; } = "";


		public string CreatedAt { get; set; } = "";


		public string UpdatedAt { get; set; } = "";


		public string Status { get; set; } = "Pending";


		public List<ZoneBlueprintStorePriceItem> PriceItems { get; set; } = new List<ZoneBlueprintStorePriceItem>();

	}
	internal static class ZoneBlueprintStoreOfferStatus
	{
		public const string Pending = "Pending";

		public const string Accepted = "Accepted";

		public const string Declined = "Declined";

		public const string Deleted = "Deleted";
	}
	internal sealed class ZoneBlueprintStoreNotification
	{
		public string NotificationId { get; set; } = "";


		public string Type { get; set; } = "";


		public string RecipientPlatformId { get; set; } = "";


		public long RecipientPlayerId { get; set; }

		public string RecipientName { get; set; } = "";


		public string ActorName { get; set; } = "";


		public string ListingId { get; set; } = "";


		public string ListingName { get; set; } = "";


		public string OfferId { get; set; } = "";


		public string Message { get; set; } = "";


		public string CreatedAt { get; set; } = "";


		public bool Read { get; set; }

		public List<string> ReadByPlatformIds { get; set; } = new List<string>();


		public List<long> ReadByPlayerIds { get; set; } = new List<long>();

	}
	internal static class ZoneBlueprintStoreNotificationType
	{
		public const string NewListing = "NewListing";

		public const string OfferReceived = "OfferReceived";

		public const string OfferAccepted = "OfferAccepted";

		public const string OfferDeclined = "OfferDeclined";

		public const string BlueprintPurchased = "BlueprintPurchased";
	}
	internal sealed class ZoneBlueprintStoreListingSummaryDto
	{
		public string ListingId { get; set; } = "";


		public string Name { get; set; } = "";


		public string SellerName { get; set; } = "";


		public ZoneBlueprintStoreListingIdentityDebugDto? DebugIdentity { get; set; }

		public List<ZoneBlueprintStorePriceItem> PriceItems { get; set; } = new List<ZoneBlueprintStorePriceItem>();


		public int PurchaseCount { get; set; }

		public int OfferCount { get; set; }

		public bool CanDelist { get; set; }

		public bool CanManage { get; set; }
	}
	internal sealed class ZoneBlueprintStoreListingIdentityDebugDto
	{
		public long SellerPlayerId { get; set; }

		public long RequesterPlayerId { get; set; }

		public string IdentityMode { get; set; } = "";

	}
	internal sealed class ZoneBlueprintStoreListingIconDto
	{
		public string ListingId { get; set; } = "";


		public string IconPngBase64 { get; set; } = "";

	}
	internal sealed class ZoneBlueprintStoreOfferDto
	{
		public string OfferId { get; set; } = "";


		public string ListingId { get; set; } = "";


		public string BuyerName { get; set; } = "";


		public List<ZoneBlueprintStorePriceItem> PriceItems { get; set; } = new List<ZoneBlueprintStorePriceItem>();


		public string PriceText { get; set; } = "";


		public string Status { get; set; } = "";


		public bool CanAccept { get; set; }

		public bool CanDecline { get; set; }

		public bool CanDelete { get; set; }

		public bool CanBuy { get; set; }
	}
	internal sealed class ZoneBlueprintStoreNotificationDto
	{
		public string NotificationId { get; set; } = "";


		public string Type { get; set; } = "";


		public string ActorName { get; set; } = "";


		public string ListingId { get; set; } = "";


		public string ListingName { get; set; } = "";


		public string OfferId { get; set; } = "";


		public string Message { get; set; } = "";


		public string CreatedAt { get; set; } = "";


		public bool Read { get; set; }
	}
	internal sealed class ZoneBlueprintStorePriceItem
	{
		public string ItemName { get; set; } = "";


		public string PrefabName { get; set; } = "";


		public string DisplayName { get; set; } = "";


		public int Amount { get; set; }
	}
	internal static class ZoneBlueprintStoreRpcType
	{
		public const string Error = "error";

		public const string List = "list";

		public const string PriceChest = "price_chest";

		public const string Publish = "publish";

		public const string Preview = "preview";

		public const string PreviewRestore = "preview_restore";

		public const string Buy = "buy";

		public const string ConfirmPurchase = "confirm";

		public const string ConfirmListing = "confirm_listing";

		public const string Delist = "delist";

		public const string EditPrice = "edit_price";

		public const string CreateOffer = "create_offer";

		public const string ListOffers = "list_offers";

		public const string DecideOffer = "decide_offer";

		public const string DeleteOffer = "delete_offer";

		public const string Notify = "notify";

		public const string GetNotifications = "get_notifications";

		public const string RecentNotifications = "recent_notifications";

		public const string ReadNotifications = "read_notifications";

		public const string SyncHidden = "sync_hidden";

		public const string Withdraw = "withdraw";

		public const string PurchaseComplete = "purchase_complete";

		public const string WithdrawComplete = "withdraw_complete";
	}
	internal sealed class ZoneBlueprintStoreRpcEnvelope : IZoneBlueprintRpcEnvelope
	{
		public string Type { get; set; } = "";


		public string PayloadYaml { get; set; } = "";


		[YamlIgnore]
		public byte[] BlueprintPayload { get; set; } = Array.Empty<byte>();

	}
	internal sealed class ZoneBlueprintStoreTransformPayload
	{
		public float[] Pos { get; set; } = new float[3];


		public float[] Rot { get; set; } = new float[4];

	}
	internal sealed class ZoneBlueprintStoreListRequest
	{
		public int RequestId { get; set; }

		public int Offset { get; set; }

		public int Limit { get; set; }

		public bool ShowHidden { get; set; }

		public bool IncludeNotifications { get; set; }

		public bool IncludeDebugIdentity { get; set; }

		public bool IconsOnly { get; set; }

		public List<string> IconListingIds { get; set; } = new List<string>();


		public int FirstIconCount { get; set; } = 6;

	}
	internal sealed class ZoneBlueprintStoreListResponse
	{
		public bool Success { get; set; }

		public string Message { get; set; } = "";


		public int RequestId { get; set; }

		public int TotalListings { get; set; }

		public int Offset { get; set; }

		public int Limit { get; set; }

		public int HiddenListings { get; set; }

		public bool HasMore { get; set; }

		public bool HasWithdrawableBalance { get; set; }

		public bool IconsOnly { get; set; }

		public List<ZoneBlueprintStoreListingSummaryDto> Listings { get; set; } = new List<ZoneBlueprintStoreListingSummaryDto>();


		public List<ZoneBlueprintStoreListingIconDto> Icons { get; set; } = new List<ZoneBlueprintStoreListingIconDto>();


		public List<ZoneBlueprintStoreNotificationDto> Notifications { get; set; } = new List<ZoneBlueprintStoreNotificationDto>();

	}
	internal sealed class ZoneBlueprintStoreSyncHiddenRequest
	{
		public List<string> HiddenListingIds { get; set; } = new List<string>();

	}
	internal interface IZoneBlueprintPayloadCarrier
	{
		string BlueprintEncoding { get; set; }

		byte[] BlueprintPayload { get; set; }
	}
	internal interface IZoneBlueprintRpcEnvelope
	{
		string Type { get; set; }

		string PayloadYaml { get; set; }

		byte[] BlueprintPayload { get; set; }
	}
	internal sealed class ZoneBlueprintStorePriceChestRequest : IZoneBlueprintPayloadCarrier
	{
		public string Name { get; set; } = "";


		public string BlueprintEncoding { get; set; } = "gzip";


		[YamlIgnore]
		public byte[] BlueprintPayload { get; set; } = Array.Empty<byte>();


		public string IconPngBase64 { get; set; } = "";


		public ZoneBlueprintStoreTransformPayload? Target { get; set; }

		public ZoneBlueprintStoreTransformPayload? PreviewAnchor { get; set; }
	}
	internal sealed class ZoneBlueprintStorePriceChestResponse
	{
		public bool Success { get; set; }

		public string Message { get; set; } = "";


		public string ListingId { get; set; } = "";


		public string Name { get; set; } = "";


		public ZoneBlueprintStoreTransformPayload? Chest { get; set; }
	}
	internal sealed class ZoneBlueprintStorePublishRequest : IZoneBlueprintPayloadCarrier
	{
		public string Name { get; set; } = "";


		public List<ZoneBlueprintStorePriceItem> PriceItems { get; set; } = new List<ZoneBlueprintStorePriceItem>();


		public string BlueprintEncoding { get; set; } = "gzip";


		[YamlIgnore]
		public byte[] BlueprintPayload { get; set; } = Array.Empty<byte>();


		public string IconPngBase64 { get; set; } = "";

	}
	internal sealed class ZoneBlueprintStoreStatusResponse
	{
		public bool Success { get; set; }

		public string Message { get; set; } = "";


		public string ListingId { get; set; } = "";


		public bool RemoveListing { get; set; }

		public ZoneBlueprintStoreListingSummaryDto? Listing { get; set; }
	}
	internal sealed class ZoneBlueprintStorePreviewRequest
	{
		public string ListingId { get; set; } = "";


		public string OfferId { get; set; } = "";

	}
	internal sealed class ZoneBlueprintStorePreviewResponse : IZoneBlueprintPayloadCarrier
	{
		public bool Success { get; set; }

		public string Message { get; set; } = "";


		public string ListingId { get; set; } = "";


		public string OfferId { get; set; } = "";


		public string Name { get; set; } = "";


		public string BlueprintEncoding { get; set; } = "gzip";


		[YamlIgnore]
		public byte[] BlueprintPayload { get; set; } = Array.Empty<byte>();

	}
	internal sealed class ZoneBlueprintStorePreviewRestoreRequest
	{
		public string Mode { get; set; } = "";


		public string ListingId { get; set; } = "";


		public string Name { get; set; } = "";


		public string BlueprintFile { get; set; } = "";

	}
	internal sealed class ZoneBlueprintStorePreviewRestoreResponse : IZoneBlueprintPayloadCarrier
	{
		public bool Success { get; set; }

		public string Message { get; set; } = "";


		public string Mode { get; set; } = "";


		public string ListingId { get; set; } = "";


		public string Name { get; set; } = "";


		public string BlueprintFile { get; set; } = "";


		public string BlueprintEncoding { get; set; } = "gzip";


		[YamlIgnore]
		public byte[] BlueprintPayload { get; set; } = Array.Empty<byte>();

	}
	internal sealed class ZoneBlueprintStoreBuyRequest
	{
		public string ListingId { get; set; } = "";


		public string OfferId { get; set; } = "";


		public ZoneBlueprintStoreTransformPayload? Target { get; set; }

		public ZoneBlueprintStoreTransformPayload? PreviewAnchor { get; set; }
	}
	internal sealed class ZoneBlueprintStoreBuyResponse
	{
		public bool Success { get; set; }

		public string Message { get; set; } = "";


		public string ListingId { get; set; } = "";


		public string OfferId { get; set; } = "";


		public string Name { get; set; } = "";


		public ZoneBlueprintStoreTransformPayload? Chest { get; set; }
	}
	internal sealed class ZoneBlueprintStoreConfirmPurchaseRequest
	{
		public string ListingId { get; set; } = "";


		public string OfferId { get; set; } = "";

	}
	internal sealed class ZoneBlueprintStoreConfirmListingRequest
	{
		public string ListingId { get; set; } = "";


		public List<ZoneBlueprintStorePriceItem> PriceItems { get; set; } = new List<ZoneBlueprintStorePriceItem>();

	}
	internal sealed class ZoneBlueprintStoreConfirmListingResponse
	{
		public bool Success { get; set; }

		public string Message { get; set; } = "";


		public string ListingId { get; set; } = "";

	}
	internal sealed class ZoneBlueprintStoreDelistRequest
	{
		public string ListingId { get; set; } = "";

	}
	internal sealed class ZoneBlueprintStoreEditPriceRequest
	{
		public string ListingId { get; set; } = "";


		public List<ZoneBlueprintStorePriceItem> PriceItems { get; set; } = new List<ZoneBlueprintStorePriceItem>();

	}
	internal sealed class ZoneBlueprintStoreCreateOfferRequest
	{
		public string ListingId { get; set; } = "";


		public List<ZoneBlueprintStorePriceItem> PriceItems { get; set; } = new List<ZoneBlueprintStorePriceItem>();

	}
	internal sealed class ZoneBlueprintStoreListOffersRequest
	{
		public string ListingId { get; set; } = "";

	}
	internal sealed class ZoneBlueprintStoreListOffersResponse
	{
		public bool Success { get; set; }

		public string Message { get; set; } = "";


		public string ListingId { get; set; } = "";


		public string ListingName { get; set; } = "";


		public bool CanManage { get; set; }

		public List<ZoneBlueprintStoreOfferDto> Offers { get; set; } = new List<ZoneBlueprintStoreOfferDto>();

	}
	internal sealed class ZoneBlueprintStoreDecideOfferRequest
	{
		public string ListingId { get; set; } = "";


		public string OfferId { get; set; } = "";


		public string Decision { get; set; } = "";

	}
	internal sealed class ZoneBlueprintStoreDeleteOfferRequest
	{
		public string ListingId { get; set; } = "";


		public string OfferId { get; set; } = "";

	}
	internal sealed class ZoneBlueprintStoreNotificationResponse
	{
		public List<ZoneBlueprintStoreNotificationDto> Notifications { get; set; } = new List<ZoneBlueprintStoreNotificationDto>();

	}
	internal sealed class ZoneBlueprintStoreGetNotificationsRequest
	{
	}
	internal sealed class ZoneBlueprintStoreRecentNotificationsRequest
	{
		public int Limit { get; set; } = 32;

	}
	internal sealed class ZoneBlueprintStoreReadNotificationsRequest
	{
		public List<string> NotificationIds { get; set; } = new List<string>();

	}
	internal sealed class ZoneBlueprintStorePurchaseCompleteResponse : IZoneBlueprintPayloadCarrier
	{
		public bool Success { get; set; }

		public string Message { get; set; } = "";


		public string ListingId { get; set; } = "";


		public string OfferId { get; set; } = "";


		public string Name { get; set; } = "";


		public string BlueprintEncoding { get; set; } = "gzip";


		[YamlIgnore]
		public byte[] BlueprintPayload { get; set; } = Array.Empty<byte>();

	}
	internal sealed class ZoneBlueprintStoreWithdrawRequest
	{
		public ZoneBlueprintStoreTransformPayload? Target { get; set; }
	}
	internal sealed class ZoneBlueprintStoreWithdrawResponse
	{
		public bool Success { get; set; }

		public string Message { get; set; } = "";


		public List<ZoneBlueprintStoreTransformPayload> Chests { get; set; } = new List<ZoneBlueprintStoreTransformPayload>();

	}
	internal static class ZoneBlueprintPlanRpcType
	{
		public const string Place = "place";

		public const string Preview = "preview";
	}
	internal sealed class ZoneBlueprintPlanRpcEnvelope : IZoneBlueprintRpcEnvelope
	{
		public string Type { get; set; } = "";


		public string PayloadYaml { get; set; } = "";


		[YamlIgnore]
		public byte[] BlueprintPayload { get; set; } = Array.Empty<byte>();

	}
	internal sealed class ZoneBlueprintPlanPlaceRequest : IZoneBlueprintPayloadCarrier
	{
		public string Name { get; set; } = "";


		public string BlueprintEncoding { get; set; } = "gzip";


		[YamlIgnore]
		public byte[] BlueprintPayload { get; set; } = Array.Empty<byte>();


		public ZoneBlueprintStoreTransformPayload? Anchor { get; set; }

		public ZoneBlueprintStoreTransformPayload? Chest { get; set; }
	}
	internal sealed class ZoneBlueprintPlanPlaceResponse : IZoneBlueprintPayloadCarrier
	{
		public bool Success { get; set; }

		public string Message { get; set; } = "";


		public string RequestedName { get; set; } = "";


		public string BlueprintName { get; set; } = "";


		public ZoneBlueprintStoreTransformPayload? Chest { get; set; }

		public string BlueprintEncoding { get; set; } = "gzip";


		[YamlIgnore]
		public byte[] BlueprintPayload { get; set; } = Array.Empty<byte>();

	}
	internal sealed class ZoneBlueprintPlanPreviewRequest
	{
		public string Name { get; set; } = "";

	}
	internal sealed class ZoneBlueprintPlanPreviewResponse : IZoneBlueprintPayloadCarrier
	{
		public bool Success { get; set; }

		public string Message { get; set; } = "";


		public string Name { get; set; } = "";


		public string BlueprintEncoding { get; set; } = "gzip";


		[YamlIgnore]
		public byte[] BlueprintPayload { get; set; } = Array.Empty<byte>();

	}
	internal sealed class ZoneBlueprintGhostOwner
	{
		public GameObject? Root { get; private set; }

		public Material? Material { get; private set; }

		public bool HasRoot
		{
			get
			{
				if ((Object)(object)Root != (Object)null)
				{
					return Object.op_Implicit((Object)(object)Root);
				}
				return false;
			}
		}

		public GameObject CreateBlueprint(ZoneBlueprintFile blueprint, string objectName, Vector3 position, Quaternion rotation, Transform? parent = null)
		{
			//IL_0014: 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)
			Destroy();
			Root = ZoneBlueprintVisuals.CreateBlueprintVisualRoot(blueprint, objectName);
			SetTransform(position, rotation);
			if ((Object)(object)parent != (Object)null)
			{
				Root.transform.SetParent(parent, true);
			}
			return Root;
		}

		public GameObject CreateEmpty(string objectName)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			Destroy();
			Root = new GameObject(objectName);
			return Root;
		}

		public void Adopt(GameObject root, Material? material)
		{
			Destroy();
			Root = root;
			Material = material;
		}

		public void SetTransform(Vector3 position, Quaternion rotation)
		{
			//IL_0014: 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)
			if (HasRoot)
			{
				Root.transform.position = position;
				Root.transform.rotation = rotation;
			}
		}

		public Material ApplyMaterial(Color color)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			Material = ApplyMaterial(Root, color, Material);
			return Material;
		}

		public Material ApplyMaterial(GameObject target, Color color)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			Material = ApplyMaterial(target, color, Material);
			return Material;
		}

		public void UpdateMaterialColor(Color color)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Material != (Object)null)
			{
				Material.color = color;
			}
		}

		public void Destroy()
		{
			if ((Object)(object)Root != (Object)null && Object.op_Implicit((Object)(object)Root))
			{
				Object.Destroy((Object)(object)Root);
			}
			if ((Object)(object)Material != (Object)null)
			{
				Object.Destroy((Object)(object)Material);
			}
			Root = null;
			Material = null;
		}

		public static Material ApplyMaterial(GameObject? root, Color color, Material? material = null)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			if (material == null)
			{
				material = CreateMaterial(color);
			}
			material.color = color;
			if ((Object)(object)root == (Object)null)
			{
				return material;
			}
			Renderer[] componentsInChildren = root.GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				Material[] sharedMaterials = val.sharedMaterials;
				for (int j = 0; j < sharedMaterials.Length; j++)
				{
					sharedMaterials[j] = material;
				}
				val.sharedMaterials = sharedMaterials;
				val.shadowCastingMode = (ShadowCastingMode)0;
				val.receiveShadows = false;
			}
			return material;
		}

		private static Material CreateMaterial(Color color)
		{
			//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_0033: Expected O, but got Unknown
			return new Material(Shader.Find("Sprites/Default") ?? Shader.Find("Unlit/Color") ?? Shader.Find("Standard"))
			{
				color = color
			};
		}
	}
	internal static class ZoneBlueprintNetworkPayload
	{
		private readonly struct QueuedWork
		{
			public string Label { get; }

			public ManualLogSource Logger { get; }

			public long Sender { get; }

			public int EstimatedBytes { get; }

			public Action Execute { get; }

			public QueuedWork(string label, ManualLogSource logger, long sender, int estimatedBytes, Action execute)
			{
				Label = label;
				Logger = logger;
				Sender = sender;
				EstimatedBytes = estimatedBytes;
				Execute = execute;
			}
		}

		public readonly struct RawEnvelopePayload
		{
			public byte[] CompressedEnvelope { get; }

			public byte[] BlueprintPayload { get; }

			public int MaxOutputBytes { get; }

			public RawEnvelopePayload(byte[] compressedEnvelope, byte[] blueprintPayload, int maxOutputBytes)
			{
				CompressedEnvelope = compressedEnvelope ?? Array.Empty<byte>();
				BlueprintPayload = blueprintPayload ?? Array.Empty<byte>();
				MaxOutputBytes = Math.Max(1, maxOutputBytes);
			}
		}

		private readonly struct IngressWindow
		{
			public float StartedAt { get; }

			public int Count { get; }

			public IngressWindow(float startedAt, int count)
			{
				StartedAt = startedAt;
				Count = count;
			}
		}

		public const string GzipEncoding = "gzip";

		private const int MaxEnvelopeOverheadBytes = 524288;

		private const int MaxCompressedEnvelopeBytes = 8388608;

		private const int MaxQueuedWorkItems = 32;

		private const int MaxQueuedWorkItemsPerSender = 4;

		private const int MaxIngressRequestsPerSender = 12;

		private const float IngressWindowSeconds = 2f;

		private const float IngressCleanupSeconds = 60f;

		private static readonly Queue<QueuedWork> WorkQueue = new Queue<QueuedWork>();

		private static readonly Dictionary<long, IngressWindow> IngressBySender = new Dictionary<long, IngressWindow>();

		private static int _queuedBytes;

		private static float _nextIngressCleanup;

		public static int MaxUploadEnvelopeBytes => Math.Max(1048576, BlueprintConfig.NetworkSettings.MaxIconBytes + 524288);

		private static int MaxGeneralEnvelopeBytes => Math.Max(16777216, MaxUploadEnvelopeBytes);

		private static int MaxCompressedBlueprintPayloadBytes => Math.Max(1048576, BlueprintConfig.NetworkSettings.MaxUploadBytes);

		private static int MaxGeneralBlueprintBytes => Math.Max(16777216, BlueprintConfig.NetworkSettings.MaxUploadBytes);

		private static int MaxQueuedPayloadBytes => Math.Max(4194304, BlueprintConfig.NetworkSettings.MaxUploadBytes * 4);

		public static void Update()
		{
			if (WorkQueue.Count == 0)
			{
				return;
			}
			QueuedWork queuedWork = WorkQueue.Dequeue();
			_queuedBytes = Math.Max(0, _queuedBytes - queuedWork.EstimatedBytes);
			try
			{
				queuedWork.Execute();
			}
			catch (Exception arg)
			{
				ManualLogSource logger = queuedWork.Logger;
				if (logger != null)
				{
					logger.LogError((object)$"{queuedWork.Label} failed: {arg}");
				}
			}
		}

		public static bool TryEnqueue(string label, ManualLogSource logger, long sender, int estimatedBytes, Action execute, out string reason)
		{
			reason = "";
			estimatedBytes = Math.Max(1, estimatedBytes);
			if (WorkQueue.Count >= 32)
			{
				reason = HomesteadLocalization.Format("hs_blueprint_rpc_queue_busy", WorkQueue.Count, 32);
				return false;
			}
			if (sender != 0L && WorkQueue.Count((QueuedWork item) => item.Sender == sender) >= 4)
			{
				reason = HomesteadLocalization.Format("hs_blueprint_rpc_queue_busy_player", 4);
				return false;
			}
			int maxQueuedPayloadBytes = MaxQueuedPayloadBytes;
			if (_queuedBytes + estimatedBytes > maxQueuedPayloadBytes)
			{
				reason = HomesteadLocalization.Format("hs_blueprint_rpc_queue_full", FormatBytes(_queuedBytes), FormatBytes(maxQueuedPayloadBytes));
				return false;
			}
			WorkQueue.Enqueue(new QueuedWork(label, logger, sender, estimatedBytes, execute));
			_queuedBytes += estimatedBytes;
			return true;
		}

		public static bool TryReserveIngress(long sender, out string reason)
		{
			reason = "";
			if (sender == 0L)
			{
				return true;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (realtimeSinceStartup >= _nextIngressCleanup)
			{
				_nextIngressCleanup = realtimeSinceStartup + 60f;
				List<long> list = null;
				foreach (KeyValuePair<long, IngressWindow> item in IngressBySender)
				{
					if (!(realtimeSinceStartup - item.Value.StartedAt <= 60f))
					{
						if (list == null)
						{
							list = new List<long>();
						}
						list.Add(item.Key);
					}
				}
				if (list != null)
				{
					foreach (long item2 in list)
					{
						IngressBySender.Remove(item2);
					}
				}
			}
			if (!IngressBySender.TryGetValue(sender, out var value) || realtimeSinceStartup - value.StartedAt >= 2f)
			{
				IngressBySender[sender] = new IngressWindow(realtimeSinceStartup, 1);
				return true;
			}
			if (value.Count >= 12)
			{
				reason = HomesteadLocalization.Format("hs_blueprint_rpc_ingress_busy_player", 12, 2f);
				return false;
			}
			IngressBySender[sender] = new IngressWindow(value.StartedAt, value.Count + 1);
			return true;
		}

		public static void WriteEnvelope(ZPackage package, string yaml, byte[]? blueprintPayload = null)
		{
			package.Write(CompressUtf8(yaml));
			bool flag = blueprintPayload != null && blueprintPayload.Length > 0;
			package.Write(flag);
			if (flag)
			{
				package.Write(blueprintPayload);
			}
		}

		public static string ReadEnvelope(ZPackage package)
		{
			byte[] blueprintPayload;
			return ReadEnvelope(package, out blueprintPayload, MaxGeneralEnvelopeBytes);
		}

		public static string ReadEnvelope(ZPackage package, int maxOutputBytes)
		{
			byte[] blueprintPayload;
			return ReadEnvelope(package, out blueprintPayload, maxOutputBytes);
		}

		public static string ReadEnvelope(ZPackage package, out byte[] blueprintPayload)
		{
			return ReadEnvelope(package, out blueprintPayload, MaxGeneralEnvelopeBytes);
		}

		public static string ReadEnvelope(ZPackage package, out byte[] blueprintPayload, int maxOutputBytes)
		{
			return ReadEnvelope(ReadRawEnvelope(package, maxOutputBytes), out blueprintPayload);
		}

		public static RawEnvelopePayload ReadRawEnvelope(ZPackage package, int maxOutputBytes)
		{
			byte[] array = package.ReadByteArray().ToArray();
			if (array.Length > 8388608)
			{
				throw new InvalidDataException(HomesteadLocalization.Format("hs_rpc_payload_too_large_compressed", FormatBytes(array.Length)));
			}
			byte[] array2 = Array.Empty<byte>();
			if (package.ReadBool())
			{
				array2 = package.ReadByteArray().ToArray();
				if (array2.Length > MaxCompressedBlueprintPayloadBytes)
				{
					throw new InvalidDataException(HomesteadLocalization.Format("hs_blueprint_payload_too_large_throw", FormatBytes(array2.Length)));
				}
			}
			return new RawEnvelopePayload(array, array2, maxOutputBytes);
		}

		public static string ReadEnvelope(RawEnvelopePayload raw, out byte[] blueprintPayload)
		{
			blueprintPayload = raw.BlueprintPayload;
			return DecompressUtf8(raw.CompressedEnvelope, raw.MaxOutputBytes);
		}

		public static bool TryCreateBlueprintPayload(string yaml, bool enforceUploadLimit, out byte[] payload, out string reason)
		{
			payload = Array.Empty<byte>();
			if (enforceUploadLimit && !TryValidateBlueprintYamlSize(yaml, out reason))
			{
				return false;
			}
			payload = CompressUtf8(yaml ?? "");
			if (payload.Length > MaxCompressedBlueprintPayloadBytes)
			{
				reason = HomesteadLocalization.Format("hs_blueprint_payload_too_large_compressed", FormatBytes(payload.Length), FormatBytes(MaxCompressedBlueprintPayloadBytes));
				payload = Array.Empty<byte>();
				return false;
			}
			reason = "";
			return true;
		}

		public static int EstimateQueuedBytes(string envelopeYaml, byte[] blueprintPayload)
		{
			long num = Encoding.UTF8.GetByteCount(envelopeYaml ?? "") + ((blueprintPayload != null) ? blueprintPayload.Length : 0);
			if (num < int.MaxValue)
			{
				return Math.Max(1, (int)num);
			}
			return int.MaxValue;
		}

		public static int EstimateQueuedBytes(RawEnvelopePayload raw)
		{
			long num = Math.Min(raw.MaxOutputBytes, Math.Max((long)raw.CompressedEnvelope.Length + 65536L, (long)raw.CompressedEnvelope.Length * 8L)) + raw.BlueprintPayload.Length;
			if (num < int.MaxValue)
			{
				return Math.Max(1, (int)num);
			}
			return int.MaxValue;
		}

		public static TEnvelope CreateEnvelope<TEnvelope, TPayload>(string type, TPayload payload) where TEnvelope : IZoneBlueprintRpcEnvelope, new()
		{
			TEnvelope val = new TEnvelope
			{
				Type = type,
				PayloadYaml = HomesteadYaml.Serialize(payload)
			};
			TEnvelope result = val;
			if ((object)payload is IZoneBlueprintPayloadCarrier zoneBlueprintPayloadCarrier && zoneBlueprintPayloadCarrier.BlueprintPayload.Length != 0)
			{
				ref TEnvelope reference = ref result;
				val = default(TEnvelope);
				if (val == null)
				{
					val = reference;
					reference = ref val;
				}
				reference.BlueprintPayload = zoneBlueprintPayloadCarrier.BlueprintPayload;
			}
			return result;
		}

		public static TPayload ReadPayload<TPayload, TEnvelope>(TEnvelope envelope) where TEnvelope : IZoneBlueprintRpcEnvelope
		{
			TPayload val = HomesteadYaml.Deserialize<TPayload>(envelope.PayloadYaml);
			if ((object)val is IZoneBlueprintPayloadCarrier zoneBlueprintPayloadCarrier && envelope.BlueprintPayload.Length != 0)
			{
				zoneBlueprintPayloadCarrier.BlueprintPayload = envelope.BlueprintPayload;
			}
			return val;
		}

		public static bool TryDeserializeBlueprintUpload(byte[] payload, string encoding, out ZoneBlueprintFile blueprint, out string reason)
		{
			blueprint = null;
			if (!TryDecodeBlueprintPayloadToYaml(payload, encoding, BlueprintConfig.NetworkSettings.MaxUploadBytes, out string yaml, out reason))
			{
				return false;
			}
			try
			{
				blueprint = HomesteadYaml.Deserialize<ZoneBlueprintFile>(yaml);
			}
			catch (Exception ex)
			{
				reason = HomesteadLocalization.Format("hs_blueprint_payload_invalid", ex.Message);
				return false;
			}
			if (!TryValidateBlueprintEntryCount(blueprint, upload: true, out reason))
			{
				return false;
			}
			return true;
		}

		public static bool TryDeserializeBlueprintPayload(byte[] payload, string encoding, out ZoneBlueprintFile blueprint, out string reason)
		{
			blueprint = null;
			if (!TryDecodeBlueprintPayloadToYaml(payload, encoding, MaxGeneralBlueprintBytes, out string yaml, out reason))
			{
				return false;
			}
			try
			{
				blueprint = HomesteadYaml.Deserialize<ZoneBlueprintFile>(yaml);
			}
			catch (Exception ex)
			{
				reason = HomesteadLocalization.Format("hs_blueprint_payload_invalid", ex.Message);
				return false;
			}
			return true;
		}

		public static bool TryDecodeBlueprintPayloadToYaml(byte[] payload, string encoding, out string yaml, out string reason)
		{
			return TryDecodeBlueprintPayloadToYaml(payload, encoding, MaxGeneralBlueprintBytes, out yaml, out reason);
		}

		public static bool TryDecodeBlueprintPayloadToYaml(byte[] payload, string encoding, int maxOutputBytes, out string yaml, out string reason)
		{
			yaml = "";
			reason = "";
			if (payload == null || payload.Length == 0)
			{
				reason = HomesteadLocalization.Text("hs_blueprint_payload_missing");
				return false;
			}
			if (payload.Length > MaxCompressedBlueprintPayloadBytes)
			{
				reason = HomesteadLocalization.Format("hs_blueprint_payload_too_large_compressed", FormatBytes(payload.Length), FormatBytes(MaxCompressedBlueprintPayloadBytes));
				return false;
			}
			if (!string.Equals(encoding, "gzip", StringComparison.OrdinalIgnoreCase))
			{
				reason = HomesteadLocalization.Format("hs_blueprint_payload_encoding_unsupported", encoding);
				return false;
			}
			try
			{
				yaml = DecompressUtf8(payload, maxOutputBytes);
				return true;
			}
			catch (Exception ex)
			{
				reason = HomesteadLocalization.Format("hs_blueprint_payload_invalid", ex.Message);
				return false;
			}
		}

		public static bool TryCreatePreviewYaml(ZoneBlueprintFile source, out string previewYaml, out string reason)
		{
			previewYaml = "";
			ZoneBlueprintFile zoneBlueprintFile = ZoneBlueprintStorePreviewPayload.CreatePreviewBlueprint(source);
			if (!TryValidateBlueprintEntryCount(zoneBlueprintFile, upload: false, out reason))
			{
				return false;
			}
			previewYaml = HomesteadYaml.Serialize(zoneBlueprintFile);
			int byteCount = Encoding.UTF8.GetByteCount(previewYaml);
			int maxUploadBytes = BlueprintConfig.NetworkSettings.MaxUploadBytes;
			if (byteCount > maxUploadBytes)
			{
				reason = HomesteadLocalization.Format("hs_blueprint_preview_payload_too_large", FormatBytes(byteCount), FormatBytes(maxUploadBytes));
				previewYaml = "";
				return false;
			}
			return true;
		}

		public static bool TryCreatePreviewPayload(ZoneBlueprintFile source, out byte[] payload, out string reason)
		{
			payload = Array.Empty<byte>();
			if (!TryCreatePreviewYaml(source, out string previewYaml, out reason))
			{
				return false;
			}
			return TryCreateBlueprintPayload(previewYaml, enforceUploadLimit: false, out payload, out reason);
		}

		public static bool TryValidateIconBase64(string payload, out string reason)
		{
			reason = "";
			if (string.IsNullOrWhiteSpace(payload))
			{
				return true;
			}
			int maxIconBytes = BlueprintConfig.NetworkSettings.MaxIconBytes;
			if (maxIconBytes <= 0)
			{
				reason = HomesteadLocalization.Text("hs_store_icon_upload_disabled");
				return false;
			}
			int num = EstimateBase64Bytes(payload);
			if (num > maxIconBytes)
			{
				reason = HomesteadLocalization.Format("hs_store_icon_too_large", FormatBytes(num), FormatBytes(maxIconBytes));
				return false;
			}
			try
			{
				byte[] array = Convert.FromBase64String(payload);
				if (array.Length > maxIconBytes)
				{
					reason = HomesteadLocalization.Format("hs_store_icon_too_large", FormatBytes(array.Length), FormatBytes(maxIconBytes));
					return false;
				}
			}
			catch (Exception ex)
			{
				reason = HomesteadLocalization.Format("hs_store_icon_payload_invalid", ex.Message);
				return false;
			}
			return true;
		}

		public static bool ShouldSendIconBase64(string payload)
		{
			if (!string.IsNullOrWhiteSpace(payload))
			{
				if (BlueprintConfig.NetworkSettings.MaxIconBytes > 0)
				{
					return EstimateBase64Bytes(payload) <= BlueprintConfig.NetworkSettings.MaxIconBytes;
				}
				return false;
			}
			return true;
		}

		public static bool TryValidateBlueprintYamlSize(string yaml, out string reason)
		{
			reason = "";
			int byteCount = Encoding.UTF8.GetByteCount(yaml ?? "");
			int maxUploadBytes = BlueprintConfig.NetworkSettings.MaxUploadBytes;
			if (byteCount > maxUploadBytes)
			{
				reason = HomesteadLocalization.Format("hs_blueprint_upload_too_large", FormatBytes(byteCount), FormatBytes(maxUploadBytes));
				return false;
			}
			return true;
		}

		public static bool TryValidateBlueprintEntryCount(ZoneBlueprintFile blueprint, bool upload, out string reason)
		{
			reason = "";
			BlueprintNetworkSettings networkSettings = BlueprintConfig.NetworkSettings;
			int num = (upload ? networkSettings.MaxEntries : networkSettings.MaxPreviewEntries);
			int valueOrDefault = (blueprint?.Entries?.Count).GetValueOrDefault();
			if (valueOrDefault > num)
			{
				string text = (upload ? HomesteadLocalization.Text("hs_blueprint_payload_kind_upload") : HomesteadLocalization.Text("hs_blueprint_payload_kind_preview"));
				reason = HomesteadLocalization.Format("hs_blueprint_entry_count_too_high", text, valueOrDefault, num);
				return false;
			}
			return true;
		}

		public static string FormatBytes(int bytes)
		{
			if (bytes >= 1048576)
			{
				return $"{(float)bytes / 1024f / 1024f:0.##} MB";
			}
			return $"{Mathf.CeilToInt((float)bytes / 1024f)} KB";
		}

		private static byte[] CompressUtf8(string value)
		{
			byte[] bytes = Encoding.UTF8.GetBytes(value ?? "");
			using MemoryStream memoryStream = new MemoryStream();
			using (GZipStream gZipStream = new GZipStream(memoryStream, CompressionMode.Compress))
			{
				gZipStream.Write(bytes, 0, bytes.Length);
			}
			return memoryStream.ToArray();
		}

		private static string DecompressUtf8(byte[] compressed, int maxOutputBytes)
		{
			using MemoryStream stream = new MemoryStream(compressed);
			using GZipStream gZipStream = new GZipStream(stream, CompressionMode.Decompress);
			using MemoryStream memoryStream = new MemoryStream();
			byte[] array = new byte[16384];
			int count;
			while ((count = gZipStream.Read(array, 0, array.Length)) > 0)
			{
				memoryStream.Write(array, 0, count);
				if (memoryStream.Length > maxOutputBytes)
				{
					throw new InvalidDataException(HomesteadLocalization.Format("hs_rpc_payload_too_large_uncompressed", FormatBytes((int)memoryStream.Length)));
				}
			}
			return Encoding.UTF8.GetString(memoryStream.ToArray());
		}

		private static int EstimateBase64Bytes(string payload)
		{
			string text = payload.Trim();
			int num = 0;
			if (text.EndsWith("==", StringComparison.Ordinal))
			{
				num = 2;
			}
			else if (text.EndsWith("=", StringComparison.Ordinal))
			{
				num = 1;
			}
			return Math.Max(0, text.Length * 3 / 4 - num);
		}
	}
	internal static class ZoneBlueprintPlanRpc
	{
		private const string RequestRpcName = "sighsorry.Homestead_BlueprintPlanRequest";

		private const string ResponseRpcName = "sighsorry.Homestead_BlueprintPlanResponse";

		private const float MaxRequestedChestDistanceFromAnchor = 512f;

		private static ManualLogSource _logger = null;

		private static bool _initialized;

		private static readonly ZoneRpcRegistrar RpcRegistrar = new ZoneRpcRegistrar();

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

		private static readonly HashSet<string> PendingPreviewRequests = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		public static void Initialize(ManualLogSource logger)
		{
			if (!_initialized)
			{
				_initialized = true;
				_logger = logger;
				RegisterRpcs();
			}
		}

		public static void Update()
		{
			RegisterRpcs();
		}

		public static void ResetForWorldSession()
		{
			PreviewCache.Clear();
			PendingPreviewRequests.Clear();
		}

		public static void RequestPlace(string name, ZoneBlueprintFile blueprint, Vector3 anchor, Quaternion anchorRotation, Vector3 chestPosition, Quaternion chestRotation)
		{
			//IL_00f0: 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_00fd: 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)
			//IL_0066: 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_0073: 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)
			byte[] payload;
			string reason;
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				Message(HomesteadLocalization.Text("hs_common_world_not_ready"), (MessageType)2);
			}
			else if (!ZoneBlueprintNetworkPayload.TryCreateBlueprintPayload(HomesteadYaml.Serialize(blueprint), enforceUploadLimit: true, out payload, out reason))
			{
				Message(reason, (MessageType)2);
			}
			else if (ZNet.instance.IsServer())
			{
				HandleResponse(ExecutePlace(new ZoneBlueprintPlanPlaceRequest
				{
					Name = name,
					BlueprintEncoding = "gzip",
					BlueprintPayload = payload,
					Anchor = ToTransformPayload(anchor, anchorRotation),
					Chest = ToTransformPayload(chestPosition, chestRotation)
				}, 0L, ((Object)(object)Player.m_localPlayer != (Object)null) ? Player.m_localPlayer.GetPlayerID() : 0, ((Object)(object)Player.m_localPlayer != (Object)null) ? HomesteadPlayerIdentity.ResolveLocalPlatformId(Player.m_localPlayer.GetPlayerID()) : ""));
			}
			else
			{
				SendRequest("place", new ZoneBlueprintPlanPlaceRequest
				{
					Name = name,
					BlueprintEncoding = "gzip",
					BlueprintPayload = payload,
					Anchor = ToTransformPayload(anchor, anchorRotation),
					Chest = ToTransformPayload(chestPosition, chestRotation)
				});
			}
		}

		public static void RequestPreview(string name)
		{
			if (!string.IsNullOrWhiteSpace(name) && !PreviewCache.ContainsKey(name) && !PendingPreviewRequests.Contains(name) && !((Object)(object)ZNet.instance == (Object)null) && !ZNet.instance.IsServer())
			{
				PendingPreviewRequests.Add(name);
				SendRequest("preview", new ZoneBlueprintPlanPreviewRequest
				{
					Name = name
				});
			}
		}

		public static bool TryGetCachedPreview(string name, out ZoneBlueprintFile blueprint)
		{
			return PreviewCache.TryGetValue(name, out blueprint);
		}

		public static bool IsPreviewPending(string name)
		{
			if (!string.IsNullOrWhiteSpace(name))
			{
				return PendingPreviewRequests.Contains(name);
			}
			return false;
		}

		private static void CachePreview(string name, ZoneBlueprintFile blueprint)
		{
			if (!string.IsNullOrWhiteSpace(name) && blueprint != null)
			{
				blueprint.Name = name;
				PreviewCache[name] = blueprint;
				PendingPreviewRequests.Remove(name);
			}
		}

		private static void RegisterRpcs()
		{
			RpcRegistrar.EnsureRegistered(delegate(ZRoutedRpc routedRpc)
			{
				routedRpc.Register<ZPackage>("sighsorry.Homestead_BlueprintPlanRequest", (Action<long, ZPackage>)RPC_HandleRequest);
				routedRpc.Register<ZPackage>("sighsorry.Homestead_BlueprintPlanResponse", (Action<long, ZPackage>)RPC_HandleResponse);
			});
		}

		private static void SendRequest<TPayload>(string type, TPayload payload)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			RegisterRpcs();
			if (ZRoutedRpc.instance != null)
			{
				ZoneBlueprintPlanRpcEnvelope zoneBlueprintPlanRpcEnvelope = CreateEnvelope(type, payload);
				ZPackage val = new ZPackage();
				ZoneBlueprintNetworkPayload.WriteEnvelope(val, HomesteadYaml.Serialize(zoneBlueprintPlanRpcEnvelope), zoneBlueprintPlanRpcEnvelope.BlueprintPayload);
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "sighsorry.Homestead_BlueprintPlanRequest", new object[1] { val });
			}
		}

		private static void RPC_HandleRequest(long sender, ZPackage package)
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			if (!ZoneBlueprintNetworkPayload.TryReserveIngress(sender, out string reason))
			{
				SendResponse(sender, CreateEnvelope("place", new ZoneBlueprintPlanPlaceResponse
				{
					Success = false,
					Message = reason
				}));
				return;
			}
			ZoneBlueprintNetworkPayload.RawEnvelopePayload rawPayload;
			try
			{
				rawPayload = ZoneBlueprintNetworkPayload.ReadRawEnvelope(package, ZoneBlueprintNetworkPayload.MaxUploadEnvelopeBytes);
			}
			catch (Exception ex)
			{
				_logger.LogError((object)$"Blueprint plan RPC failed: {ex}");
				SendResponse(sender, CreateEnvelope("place", new ZoneBlueprintPlanPlaceResponse
				{
					Success = false,
					Message = ex.Message
				}));
				return;
			}
			int estimatedBytes = ZoneBlueprintNetworkPayload.EstimateQueuedBytes(rawPayload);
			if (!ZoneBlueprintNetworkPayload.TryEnqueue("Blueprint plan RPC", _logger, sender, estimatedBytes, delegate
			{
				ZoneBlueprintPlanRpcEnvelope response;
				try
				{
					byte[] blueprintPayload;
					ZoneBlueprintPlanRpcEnvelope zoneBlueprintPlanRpcEnvelope = HomesteadYaml.Deserialize<ZoneBlueprintPlanRpcEnvelope>(ZoneBlueprintNetworkPayload.ReadEnvelope(rawPayload, out blueprintPayload));
					zoneBlueprintPlanRpcEnvelope.BlueprintPayload = blueprintPayload;
					response = ExecuteRequest(zoneBlueprintPlanRpcEnvelope, sender);
				}
				catch (Exception ex2)
				{
					_logger.LogError((object)$"Blueprint plan RPC failed: {ex2}");
					response = CreateEnvelope("place", new ZoneBlueprintPlanPlaceResponse
					{
						Success = false,
						Message = ex2.Message
					});
				}
				SendResponse(sender, response);
			}, out string reason2))
			{
				SendResponse(sender, CreateEnvelope("place", new ZoneBlueprintPlanPlaceResponse
				{
					Success = false,
					Message = reason2
				}));
			}
		}

		private static void RPC_HandleResponse(long sender, ZPackage package)
		{
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
			{
				return;
			}
			try
			{
				byte[] blueprintPayload;
				ZoneBlueprintPlanRpcEnvelope zoneBlueprintPlanRpcEnvelope = HomesteadYaml.Deserialize<ZoneBlueprintPlanRpcEnvelope>(ZoneBlueprintNetworkPayload.ReadEnvelope(package, out blueprintPayload));
				zoneBlueprintPlanRpcEnvelope.BlueprintPayload = blueprintPayload;
				HandleResponse(zoneBlueprintPlanRpcEnvelope);
			}
			catch (Exception ex)
			{
				_logger.LogWarning((object)("Failed to read blueprint plan response: " + ex.Message));
			}
		}

		private static ZoneBlueprintPlanRpcEnvelope ExecuteRequest(ZoneBlueprintPlanRpcEnvelope request, long sender)
		{
			if (request.Type == "preview")
			{
				return ExecutePreview(ReadPayload<ZoneBlueprintPlanPreviewRequest>(request));
			}
			if (!TryResolveRequester(sender, out long playerId, out string reason))
			{
				return CreateEnvelope(request.Type, new ZoneBlueprintPlanPlaceResponse
				{
					Success = false,
					Message = reason
				});
			}
			if (request.Type == "place")
			{
				return ExecutePlace(ReadPayload<ZoneBlueprintPlanPlaceRequest>(request), sender, playerId, HomesteadPlayerIdentity.ResolvePlatformId(null, sender, playerId));
			}
			return CreateEnvelope(request.Type, new ZoneBlueprintPlanPlaceResponse
			{
				Success = false,
				Message = HomesteadLocalization.Format("hs_blueprint_plan_unknown_action", request.Type)
			});
		}

		private static ZoneBlueprintPlanRpcEnvelope ExecutePlace(ZoneBlueprintPlanPlaceRequest request, long sender, long playerId, string ownerPlatformId)
		{
			//IL_0034: 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_0044: 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_0152: 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_0154: 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_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: 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_0179: 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_0215: 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)
			ZoneBlueprintPlanPlaceRequest request2 = request;
			if (!TryReadTransform(request2.Anchor, out var position, out var rotation) || !TryReadTransform(request2.Chest, out var position2, out var rotation2) || !IsFinite(position) || !IsFinite(rotation) || !IsFinite(rotation2))
			{
				return CreateEnvelope("place", Fail(HomesteadLocalization.Text("hs_blueprint_place_payload_missing_transform")));
			}
			if (!ZoneBlueprintNetworkPayload.TryDeserializeBlueprintUpload(request2.BlueprintPayload, request2.BlueprintEncoding, out ZoneBlueprintFile blueprint, out string reason))
			{
				return CreateEnvelope("place", Fail(reason));
			}
			string savedName;
			HomesteadCommandResult homesteadCommandResult = ZoneBlueprintCommands.SaveUploadedBlueprintForPlan(request2.Name, blueprint, playerId, out savedName);
			if (!homesteadCommandResult.Success)
			{
				return CreateEnvelope("place", Fail(homesteadCommandResult.Message));
			}
			try
			{
				ZoneBlueprintFile zoneBlueprintFile = ZoneBlueprintCommands.LoadBlueprintForPlan(savedName);
				if (ZoneBlueprintCommands.CreateLoadPlanForBlueprint(zoneBlueprintFile, position, rotation).Entries.Count == 0)
				{
					return CreateEnvelope("place", Fail(HomesteadLocalization.Format("hs_blueprint_no_valid_entries", savedName)));
				}
				if (!ZoneBlueprintNetworkPayload.TryCreateBlueprintPayload(HomesteadYaml.Serialize(zoneBlueprintFile), enforceUploadLimit: false, out byte[] payload, out string reason2))
				{
					return CreateEnvelope("place", Fail(reason2));
				}
				Vector3 val = ResolvePlanChestPosition(zoneBlueprintFile, position, rotation, position2, rotation2);
				ownerPlatformId = (string.IsNullOrWhiteSpace(ownerPlatformId) ? HomesteadPlayerIdentity.ResolvePlatformId(null, sender, playerId) : ownerPlatformId);
				HomesteadCommandResult homesteadCommandResult2 = ZoneBlueprintPlanChestPrefab.PlacePlanChest(savedName, playerId, ownerPlatformId, position, rotation, val, rotation2, sender);
				return CreateEnvelope("place", new ZoneBlueprintPlanPlaceResponse
				{
					Success = homesteadCommandResult2.Success,
					Message = ((homesteadCommandResult2.Success && !string.Equals(savedName, request2.Name, StringComparison.OrdinalIgnoreCase)) ? HomesteadLocalization.Format("hs_blueprint_server_saved_as_existing", homesteadCommandResult2.Message, savedName) : homesteadCommandResult2.Message),
					RequestedName = request2.Name,
					BlueprintName = savedName,
					Chest = (homesteadCommandResult2.Success ? ToTransformPayload(val, rotation2) : null),
					BlueprintEncoding = "gzip",
					BlueprintPayload = (homesteadCommandResult2.Success ? payload : Array.Empty<byte>())
				});
			}
			catch (Exception ex)
			{
				return CreateEnvelope("place", Fail(ex.Message));
			}
			ZoneBlueprintPlanPlaceResponse Fail(string message)
			{
				return new ZoneBlueprintPlanPlaceResponse
				{
					Success = false,
					Message = message,
					RequestedName = request2.Name
				};
			}
		}

		private static ZoneBlueprintPlanRpcEnvelope ExecutePreview(ZoneBlueprintPlanPreviewRequest request)
		{
			try
			{
				if (!ZoneBlueprintNetworkPayload.TryCreateBlueprintPayload(ZoneBlueprintCommands.SerializePreviewBlueprintForPlan(request.Name), enforceUploadLimit: false, out byte[] payload, out string reason))
				{
					throw new InvalidOperationException(reason);
				}
				return CreateEnvelope("preview", new ZoneBlueprintPlanPreviewResponse
				{
					Success = true,
					Name = request.Name,
					BlueprintEncoding = "gzip",
					BlueprintPayload = payload
				});
			}
			catch (Exception ex)
			{
				return CreateEnvelope("preview", new ZoneBlueprintPlanPreviewResponse
				{
					Success = false,
					Name = request.Name,
					Message = ex.Message
				});
			}
		}

		private static void SendResponse(long target, ZoneBlueprintPlanRpcEnvelope response)
		{
			//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();
			ZoneBlueprintNetworkPayload.WriteEnvelope(val, HomesteadYaml.Serialize(response), response.BlueprintPayload);
			ZRoutedRpc.instance.InvokeRoutedRPC(target, "sighsorry.Homestead_BlueprintPlanResponse", new object[1] { val });
		}

		private static void HandleResponse(ZoneBlueprintPlanRpcEnvelope response)
		{
			if (response.Type == "preview")
			{
				ZoneBlueprintPlanPreviewResponse zoneBlueprintPlanPreviewResponse = ReadPayload<ZoneBlueprintPlanPreviewResponse>(response);
				PendingPreviewRequests.Remove(zoneBlueprintPlanPreviewResponse.Name);
				if (!zoneBlueprintPlanPreviewResponse.Success)
				{
					return;
				}
				try
				{
					if (ZoneBlueprintNetworkPayload.TryDeserializeBlueprintPayload(zoneBlueprintPlanPreviewResponse.BlueprintPayload, zoneBlueprintPlanPreviewResponse.BlueprintEncoding, out ZoneBlueprintFile blueprint, out string reason))
					{
						CachePreview(zoneBlueprintPlanPreviewResponse.Name, blueprint);
					}
					else
					{
						_logger.LogWarning((object)("Failed to cache server blueprint preview '" + zoneBlueprintPlanPreviewResponse.Name + "': " + reason));
					}
					return;
				}
				catch (Exception ex)
				{
					_logger.LogWarning((object)("Failed to cache server blueprint preview '" + zoneBlueprintPlanPreviewResponse.Name + "': " + ex.Message));
					return;
				}
			}
			ZoneBlueprintPlanPlaceResponse zoneBlueprintPlanPlaceResponse = ReadPayload<ZoneBlueprintPlanPlaceResponse>(response);
			if (zoneBlueprintPlanPlaceResponse.Success)
			{
				TryPlayPlanChestPlaceVfx(zoneBlueprintPlanPlaceResponse.Chest);
			}
			if (zoneBlueprintPlanPlaceResponse.Success && !string.IsNullOrWhiteSpace(zoneBlueprintPlanPlaceResponse.BlueprintName) && zoneBlueprintPlanPlaceResponse.BlueprintPayload.Length != 0)
			{
				try
				{
					if (ZoneBlueprintNetworkPayload.TryDecodeBlueprintPayloadToYaml(zoneBlueprintPlanPlaceResponse.BlueprintPayload, zoneBlueprintPlanPlaceResponse.BlueprintEncoding, out string yaml, out string reason2))
					{
						ZoneBlueprintFile blueprint2 = HomesteadYaml.Deserialize<ZoneBlueprintFile>(yaml);
						CachePreview(zoneBlueprintPlanPlaceResponse.BlueprintName, blueprint2);
						ZoneBlueprintCommands.EnsureLocalPlanBlueprintCopy(zoneBlueprintPlanPlaceResponse.BlueprintName, yaml);
					}
					else
					{
						_logger.LogWarning((object)("Failed to decode server blueprint copy '" + zoneBlueprintPlanPlaceResponse.BlueprintName + "': " + reason2));
					}
				}
				catch (Exception ex2)
				{
					_logger.LogWarning((object)("Failed to save server blueprint copy '" + zoneBlueprintPlanPlaceResponse.BlueprintName + "' locally: " + ex2.Message));
				}
			}
			if (!string.IsNullOrWhiteSpace(zoneBlueprintPlanPlaceResponse.Message))
			{
				Message(zoneBlueprintPlanPlaceResponse.Message, (MessageType)(zoneBlueprintPlanPlaceResponse.Success ? 1 : 2));
			}
		}

		private static void TryPlayPlanChestPlaceVfx(ZoneBlueprintStoreTransformPayload? chest)
		{
			//IL_0027: 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)
			if ((!((Object)(object)ZNet.instance != (Object)null) || !ZNet.instance.IsServer()) && TryReadTransform(chest, out var position, out var rotation))
			{
				ZoneBlueprintPlanChestPrefab.PlayPlaceEffect(position, rotation);
			}
		}

		private static bool TryResolveRequester(long sender, out long playerId, out string reason)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			playerId = 0L;
			reason = "";
			if ((Object)(object)ZNet.instance == (Object)null || ZDOMan.instance == null)
			{
				reason = HomesteadLocalization.Text("hs_common_world_not_ready");
				return false;
			}
			ZNetPeer peer = ZNet.instance.GetPeer(sender);
			if (peer == null || !peer.IsReady())
			{
				reason = HomesteadLocalization.Text("hs_common_player_not_ready");
				return false;
			}
			if (((ZDOID)(ref peer.m_characterID)).IsNone())
			{
				reason = HomesteadLocalization.Text("hs_store_character_missing");
				return false;
			}
			ZDO zDO = ZDOMan.instance.GetZDO(peer.m_characterID);
			if (zDO == null)
			{
				reason = HomesteadLocalization.Text("hs_store_character_missing");
				return false;
			}
			playerId = zDO.GetLong(ZDOVars.s_playerID, 0L);
			if (playerId == 0L)
			{
				reason = HomesteadLocalization.Text("hs_dismantle_playerid_missing");
				return false;
			}
			return true;
		}

		private static ZoneBlueprintPlanRpcEnvelope CreateEnvelope<TPayload>(string type, TPayload payload)
		{
			return ZoneBlueprintNetworkPayload.CreateEnvelope<ZoneBlueprintPlanRpcEnvelope, TPayload>(type, payload);
		}

		private static TPayload ReadPayload<TPayload>(ZoneBlueprintPlanRpcEnvelope envelope)
		{
			return ZoneBlueprintNetworkPayload.ReadPayload<TPayload, ZoneBlueprintPlanRpcEnvelope>(envelope);
		}

		private static ZoneBlueprintStoreTransformPayload ToTransformPayload(Vector3 position, Quaternion rotation)
		{
			//IL_000f: 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_0021: 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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: 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)
			ZoneBlueprintStoreTransformPayload zoneBlueprintStoreTransformPayload = new ZoneBlueprintStoreTransformPayload();
			zoneBlueprintStoreTransformPayload.Pos = new float[3] { position.x, position.y, position.z };
			zoneBlueprintStoreTransformPayload.Rot = new float[4] { rotation.x, rotation.y, rotation.z, rotation.w };
			return zoneBlueprintStoreTransformPayload;
		}

		private static bool TryReadTransform(ZoneBlueprintStoreTransformPayload? payload, out Vector3 position, out Quaternion rotation)
		{
			//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)
			//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_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			position = Vector3.zero;
			rotation = Quaternion.identity;
			if (payload == null || payload.Pos == null || payload.Rot == null || payload.Pos.Length < 3 || payload.Rot.Length < 4)
			{
				return false;
			}
			position = new Vector3(payload.Pos[0], payload.Pos[1], payload.Pos[2]);
			rotation = new Quaternion(payload.Rot[0], payload.Rot[1], payload.Rot[2], payload.Rot[3]);
			return true;
		}

		private static Vector3 ResolvePlanChestPosition(ZoneBlueprintFile blueprint, Vector3 anchor, Quaternion anchorRotation, Vector3 requestedChestPosition, Quaternion chestRotation)
		{
			//IL_0000: 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_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_0029: 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_002f: Unknown result type (might be due to invalid IL or missing references)
			if (!IsFinite(requestedChestPosition) || ((Vector3)(ref requestedChestPosition)).sqrMagnitude < 0.0001f || !IsWithinHorizontalDistance(anchor, requestedChestPosition, 512f))
			{
				return ZoneBlueprintCommands.GetPlanChestPosition(blueprint, anchor, anchorRotation, chestRotation);
			}
			return requestedChestPosition;
		}

		private static bool IsWithinHorizontalDistance(Vector3 origin, Vector3 target, float maxDistance)
		{
			//IL_0000: 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)
			//IL_000d: 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)
			float num = target.x - origin.x;
			float num2 = target.z - origin.z;
			return num * num + num2 * num2 <= maxDistance * maxDistance;
		}

		private static bool IsFinite(Vector3 value)
		{
			//IL_0000: 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_001a: Unknown result type (might be due to invalid IL or missing references)
			if (IsFinite(value.x) && IsFinite(value.y))
			{
				return IsFinite(value.z);
			}
			return false;
		}

		private static bool IsFinite(Quaternion value)
		{
			//IL_0000: 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_001a: 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)
			if (IsFinite(value.x) && IsFinite(value.y) && IsFinite(value.z))
			{
				return IsFinite(value.w);
			}
			return false;
		}

		private static bool IsFinite(float value)
		{
			if (!float.IsNaN(value))
			{
				return !float.IsInfinity(value);
			}
			return false;
		}

		private static void Message(string message, MessageType type)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			ManualLogSource logger = _logger;
			if (logger != null)
			{
				logger.LogInfo((object)message);
			}
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer != null)
			{
				((Character)localPlayer).Message(type, message, 0, (Sprite)null);
			}
		}
	}
	internal sealed class ZoneBlueprintPlacementTool : MonoBehaviour
	{
		private const float MaxPlacementDistance = 128f;

		private static ManualLogSource? _logger;

		private static ZoneBlueprintPlacementTool? _instance;

		private string _blueprintName = "";

		private ZoneBlueprintFile? _blueprint;

		private GameObject? _previewRoot;

		private GameObject? _chestPreviewRoot;

		private bool _active;

		private int _suppressInputFrames;

		private Vector3 _anchor;

		private Quaternion _anchorRotation = Quaternion.identity;

		private Quaternion _chestRotation = Quaternion.identity;

		private float _placementYaw;

		private float _heightOffset;

		private Vector3 _horizontalOffset;

		public static bool IsActive => _instance?._active ?? false;

		public static void Initialize(ManualLogSource logger)
		{
			_logger = logger;
			EnsureInstance();
		}

		public static void Activate(Player player, string blueprintName)
		{
			EnsureInstance();
			_instance?.ActivateInternal(player, blueprintName);
		}

		public static void Deactivate()
		{
			_instance?.DeactivateInternal();
		}

		private static void EnsureInstance()
		{
			//IL_001f: 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_002a: Expected O, but got Unknown
			if (!((Object)(object)_instance != (Object)null) || !Object.op_Implicit((Object)(object)_instance))
			{
				GameObject val = new GameObject("HomesteadBlueprintPlacementTool");
				Object.DontDestroyOnLoad((Object)val);
				_instance = val.AddComponent<ZoneBlueprintPlacementTool>();
			}
		}

		private void ActivateInternal(Player player, string blueprintName)
		{
			//IL_003a: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: 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 (_active && string.Equals(_blueprintName, blueprintName, StringComparison.OrdinalIgnoreCase))
			{
				return;
			}
			ClearPreview();
			_active = true;
			_blueprintName = blueprintName;
			_suppressInputFrames = 2;
			Quaternion rotation = ((Component)player).transform.rotation;
			_placementYaw = ((Quaternion)(ref rotation)).eulerAngles.y;
			_chestRotation = GetAimYawRotation(player);
			_heightOffset = 0f;
			_horizontalOffset = Vector3.zero;
			if (!ZoneBlueprintCommands.TryLoadBlueprint(blueprintName, out ZoneBlueprintFile blueprint))
			{
				Message(player, HomesteadLocalization.Format("hs_blueprint_load_failed_plain", blueprintName));
				DeactivateInternal();
				return;
			}
			_blueprint = blueprint;
			_previewRoot = ZoneBlueprintVisuals.CreateBlueprintVisualRoot(blueprint, "HomesteadBlueprintPreview_" + blueprintName);
			_previewRoot.transform.SetParent(((Component)this).transform, false);
			_chestPreviewRoot = ZoneBlueprintPlanChestPrefab.CreatePreview();
			GameObject? chestPreviewRoot = _chestPreviewRoot;
			if (chestPreviewRoot != null)
			{
				chestPreviewRoot.transform.SetParent(((Component)this).transform, false);
			}
		}

		private void DeactivateInternal()
		{
			//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)
			_active = false;
			_blueprintName = "";
			_blueprint = null;
			_heightOffset = 0f;
			_horizontalOffset = Vector3.zero;
			ZoneAreaToolStatusHud.Hide();
			ClearPreview();
		}

		private void Update()
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: 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_0067: 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_016d: 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_0172: 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_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//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)
			if (!_active)
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || !IsHoldingBuildTool(localPlayer))
			{
				DeactivateInternal();
				return;
			}
			if (!TryGetAimPoint(localPlayer, out var point))
			{
				SetPreviewVisible(visible: false);
				ZoneAreaToolStatusHud.Hide();
				return;
			}
			_anchorRotation = Quaternion.Euler(0f, _placementYaw, 0f);
			_anchor = GetAdjustedAnchor(point, _anchorRotation);
			_chestRotation = GetAimYawRotation(localPlayer);
			if (ShouldBlockInput())
			{
				UpdatePreviewTransform();
				UpdateStatusHud();
				return;
			}
			if (_suppressInputFrames > 0)
			{
				_suppressInputFrames--;
				UpdatePreviewTransform();
				UpdateStatusHud();
				return;
			}
			if (Input.GetKeyDown((KeyCode)27))
			{
				ResetOffsets();
			}
			float axis = Input.GetAxis("Mouse ScrollWheel");
			if (Mathf.Abs(axis) > 0.001f)
			{
				ZoneAreaCameraZoomGuard.SuppressWheelZoomThisFrame();
				float num = ((axis > 0f) ? PlacementControlConfig.RotationStep : (0f - PlacementControlConfig.RotationStep));
				_placementYaw = Mathf.Repeat(_placementYaw + num, 360f);
			}
			if (PlacementControlConfig.IsPlacementAdjustModifierHeld() && (Input.GetKeyDown((KeyCode)280) || Input.GetKeyDown((KeyCode)281)))
			{
				float num2 = (Input.GetKeyDown((KeyCode)280) ? 1f : (-1f));
				_heightOffset = RoundHeightOffset(_heightOffset + num2 * PlacementControlConfig.HeightStep);
			}
			Vector3 val = (PlacementControlConfig.IsPlacementAdjustModifierHeld() ? ZonePlacementOffset.GetArrowKeyLocalNudge() : Vector3.zero);
			if (((Vector3)(ref val)).sqrMagnitude > 0.0001f)
			{
				_horizontalOffset += val * PlacementControlConfig.HorizontalStep;
			}
			_anchorRotation = Quaternion.Euler(0f, _placementYaw, 0f);
			_anchor = GetAdjustedAnchor(point, _anchorRotation);
			UpdatePreviewTransform();
			UpdateStatusHud();
			if (Input.GetMouseButtonDown(0))
			{
				Place(localPlayer);
			}
		}

		private void UpdateStatusHud()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			ZoneAreaToolStatusHud.ShowBlueprint("Blueprint Placement", _placementYaw, _horizontalOffset, _heightOffset);
		}

		private void OnDestroy()
		{
			ClearPreview();
			if ((Object)(object)_instance == (Object)(object)this)
			{
				_instance = null;
			}
		}

		private void Place(Player player)
		{
			//IL_001e: 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_002a: Unknown result type (might be due to invalid IL or missing references)
			if (_blueprint != null && !string.IsNullOrWhiteSpace(_blueprintName))
			{
				HomesteadCommandResult homesteadCommandResult = ZoneBlueprintCommands.PlaceBlueprintPlanAt(_blueprintName, player, _anchor, _anchorRotation, _chestRotation);
				Message(player, homesteadCommandResult.Message, (MessageType)(homesteadCommandResult.Success ? 1 : 2));
			}
		}

		private void UpdatePreviewTransform()
		{
			//IL_0027: 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_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_previewRoot == (Object)null)
			{
				return;
			}
			_previewRoot.SetActive(true);
			_previewRoot.transform.position = _anchor;
			_previewRoot.transform.rotation = _anchorRotation;
			if (_blueprint == null)
			{
				return;
			}
			if ((Object)(object)_chestPreviewRoot == (Object)null)
			{
				_chestPreviewRoot = ZoneBlueprintPlanChestPrefab.CreatePreview();
				GameObject? chestPreviewRoot = _chestPreviewRoot;
				if (chestPreviewRoot != null)
				{
					chestPreviewRoot.transform.SetParent(((Component)this).transform, false);
				}
			}
			if ((Object)(object)_chestPreviewRoot != (Object)null)
			{
				_chestPreviewRoot.SetActive(true);
				_chestPreviewRoot.transform.position = ZoneBlueprintCommands.GetPlanChestPosition(_blueprint, _anchor, _anchorRotation, _chestRotation);
				_chestPreviewRoot.transform.rotation = _chestRotation;
			}
		}

		private void SetPreviewVisible(bool visible)
		{
			if ((Object)(object)_previewRoot != (Object)null)
			{
				_previewRoot.SetActive(visible);
			}
			if ((Object)(object)_chestPreviewRoot != (Object)null)
			{
				_chestPreviewRoot.SetActive(visible);
			}
		}

		private void ClearPreview()
		{
			if ((Object)(object)_previewRoot != (Object)null)
			{
				Object.Destroy((Object)(object)_previewRoot);
				_previewRoot = null;
			}
			if ((Object)(object)_chestPreviewRoot != (Object)null)
			{
				Object.Destroy((Object)(object)_chestPreviewRoot);
				_chestPreviewRoot = null;
			}
		}

		private static bool TryGetAimPoint(Player player, out Vector3 point)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: 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_002d: 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_004b: Unknown result type (might be due to invalid IL or missing references)
			Camera mainCamera = Utils.GetMainCamera();
			RaycastHit val = default(RaycastHit);
			if ((Object)(object)mainCamera != (Object)null && Physics.Raycast(mainCamera.ScreenPointToRay(new Vector3((float)Screen.width * 0.5f, (float)Screen.height * 0.5f)), ref val, 128f, -5, (QueryTriggerInteraction)1))
			{
				point = ((RaycastHit)(ref val)).point;
				point.y = SampleGroundY(point.x, point.z, point.y);
				return true;
			}
			point = ((Component)player).transform.position + ((Component)player).transform.forward * 8f;
			point.y = SampleGroundY(point.x, point.z, ((Component)player).transform.position.y);
			return true;
		}

		private Vector3 GetAdjustedAnchor(Vector3 aimPoint, Quaternion rotation)
		{
			//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_0003: 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)
			return aimPoint + ZonePlacementOffset.ToWorldOffset(rotation, _horizontalOffset, _heightOffset);
		}

		private void ResetOffsets()
		{
			//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)
			_heightOffset = 0f;
			_horizontalOffset = Vector3.zero;
		}

		private static float SampleGroundY(float x, float z, float fallbackY)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ZoneSystem.instance == (Object)null)
			{
				return fallbackY;
			}
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(x, fallbackY, z);
			Vector3 val2 = default(Vector3);
			Biome val3 = default(Biome);
			BiomeArea val4 = default(BiomeArea);
			Heightmap val5 = default(Heightmap);
			ZoneSystem.instance.GetGroundData(ref val, ref val2, ref val3, ref val4, ref val5);
			return val.y;
		}

		private static Quaternion GetYawRotation(Quaternion rotation)
		{
			//IL_0007: 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)
			return Quaternion.Euler(0f, ((Quaternion)(ref rotation)).eulerAngles.y, 0f);
		}

		private static Quaternion GetAimYawRotation(Player player)
		{
			//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_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			Camera mainCamera = Utils.GetMainCamera();
			if ((Object)(object)mainCamera != (Object)null)
			{
				Vector3 forward = ((Component)mainCamera).transform.forward;
				forward.y = 0f;
				if (((Vector3)(ref forward)).sqrMagnitude > 0.0001f)
				{
					return Quaternion.LookRotation(((Vector3)(ref forward)).normalized, Vector3.up);
				}
			}
			return GetYawRotation(((Component)player).transform.rotation);
		}

		private static float RoundHeightOffset(float value)
		{
			return Mathf.Round(value * 1000f) / 1000f;
		}

		private static bool IsHoldingBuildTool(Player player)
		{
			return (Object)(object)((Humanoid)player).GetRightItem()?.m_shared?.m_buildPieces != (Object)null;
		}

		private static bool ShouldBlockInput()
		{
			if (Hud.IsPieceSelectionVisible() || Console.IsVisible() || TextInput.IsVisible() || Menu.IsVisible() || InventoryGui.IsVisible() || Minimap.IsOpen())
			{
				return true;
			}
			if ((Object)(object)Chat.instance != (Object)null)
			{
				return Chat.instance.HasFocus();
			}
			return false;
		}

		private static void Message(Player player, string message)
		{
			Message(player, message, (MessageType)1);
		}

		private static void Message(Player player, string message, MessageType type)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			ManualLogSource? logger = _logger;
			if (logger != null)
			{
				logger.LogInfo((object)message);
			}
			((Character)player).Message(type, message, 0, (Sprite)null);
		}
	}
	internal static class ZoneBlueprintChestCommands
	{
		private enum BlueprintChestKind
		{
			Build,
			StorePrice,
			StorePurchase,
			StorePayout
		}

		private sealed class BlueprintChestCommandRequest
		{
			public bool DryRun { get; set; }
		}

		private sealed class BlueprintChestCommandResult
		{
			public bool Success { get; set; }

			public bool DryRun { get; set; }

			public int Total { get; set; }

			public int Deleted { get; set; }

			public int Build { get; set; }

			public int StorePrice { get; set; }

			public int StorePurchase { get; set; }

			public int StorePayout { get; set; }

			public int DraftFilesDeleted { get; set; }

			public string Message { get; set; } = "";


			public static BlueprintChestCommandResult Fail(string message)
			{
				return new BlueprintChestCommandResult
				{
					Success = false,
					Message = message
				};
			}
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static ConsoleEvent <0>__HandleClearCommand;

			public static Action<long, ZPackage> <1>__RPC_HandleRequest;

			public static Action<long, ZPackage> <2>__RPC_HandleResult;
		}

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

			public static ConsoleOptionsFetcher <>9__6_0;

			public static Action<ZRoutedRpc> <>9__7_0;

			public static Func<string, bool> <>9__8_0;

			public static Func<ZDO, bool> <>9__12_0;

			internal List<string> <Initialize>b__6_0()
			{
				return new List<string>(1) { "dry" };
			}

			internal void <RegisterRpcs>b__7_0(ZRoutedRpc routedRpc)
			{
				routedRpc.Register<ZPackage>("sighsorry.Homestead_BlueprintChestCommandRequest", (Action<long, ZPackage>)RPC_HandleRequest);
				routedRpc.Register<ZPackage>("sighsorry.Homestead_BlueprintChestCommandResult", (Action<long, ZPackage>)RPC_HandleResult);
			}

			internal bool <HandleClearCommand>b__8_0(string arg)
			{
				if (!arg.Equals("dry", StringComparison.OrdinalIgnoreCase))
				{
					return arg.Equals("dry-run", StringComparison.OrdinalIgnoreCase);
				}
				return true;
			}

			internal bool <Execute>b__12_0(ZDO zdo)
			{
				BlueprintChestKind kind;
				if (zdo != null && zdo.IsValid())
				{
					return TryGetChestKind(zdo, out kind);
				}
				return false;
			}
		}

		private const string ClearCommand = "hs_clearchests";

		private const string RequestRpcName = "sighsorry.Homestead_BlueprintChestCommandRequest";

		private const string ResultRpcName = "sighsorry.Homestead_BlueprintChestCommandResult";

		private static ManualLogSource _logger = null;

		private static bool _initialized;

		private static readonly ZoneRpcRegistrar RpcRegistrar = new ZoneRpcRegistrar();

		public static void Initialize(ManualLogSource logger)
		{
			//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_0039: Expected O, but got Unknown
			//IL_0060: 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_005d: Expected O, but got Unknown
			if (_initialized)
			{
				return;
			}
			_initialized = true;
			_logger = logger;
			object obj = <>O.<0>__HandleClearCommand;
			if (obj == null)
			{
				ConsoleEvent val = HandleClearCommand;
				<>O.<0>__HandleClearCommand = val;
				obj = (object)val;
			}
			object obj2 = <>c.<>9__6_0;
			if (obj2 == null)
			{
				ConsoleOptionsFetcher val2 = () => new List<string>(1) { "dry" };
				<>c.<>9__6_0 = val2;
				obj2 = (object)val2;
			}
			new ConsoleCommand("hs_clearchests", "[dry] - Deletes all Homestead blueprint/build/store chests in the world.", (ConsoleEvent)obj, false, false, false, false, false, (ConsoleOptionsFetcher)obj2, false, false, false);
			RegisterRpcs();
		}

		internal static void RegisterRpcs()
		{
			RpcRegistrar.EnsureRegistered(delegate(ZRoutedRpc routedRpc)
			{
				routedRpc.Register<ZPackage>("sighsorry.Homestead_BlueprintChestCommandRequest", (Action<long, ZPackage>)RPC_HandleRequest);
				routedRpc.Register<ZPackage>("sighsorry.Homestead_BlueprintChestCommandResult", (Action<long, ZPackage>)RPC_HandleResult);
			});
		}

		private static void HandleClearCommand(ConsoleEventArgs args)
		{
			EnsureCommandReady();
			bool dryRun = args.Args.Skip(1).Any((string arg) => arg.Equals("dry", StringComparison.OrdinalIgnoreCase) || arg.Equals("dry-run", StringComparison.OrdinalIgnoreCase));
			DispatchRequest(new BlueprintChestCommandRequest
			{
				DryRun = dryRun
			}, args.Context);
		}

		private static void DispatchRequest(BlueprintChestCommandRequest request, Terminal? context)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			if (ZNet.instance.IsServer())
			{
				ShowResult(Execute(request), context);
				return;
			}
			RegisterRpcs();
			ZPackage val = new ZPackage();
			val.Write(HomesteadYaml.Serialize(request));
			ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "sighsorry.Homestead_BlueprintChestCommandRequest", new object[1] { val });
			if (context != null)
			{
				context.AddString("hs_clearchests request sent to server.");
			}
		}

		private static void RPC_HandleRequest(long sender, ZPackage package)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer())
			{
				BlueprintChestCommandResult value;
				try
				{
					value = (IsAuthorizedSender(sender) ? Execute(HomesteadYaml.Deserialize<BlueprintChestCommandRequest>(package.ReadString())) : BlueprintChestCommandResult.Fail("Admin only."));
				}
				catch (Exception ex)
				{
					_logger.LogError((object)$"Blueprint chest command RPC failed: {ex}");
					value = BlueprintChestCommandResult.Fail(ex.Message);
				}
				ZPackage val = new ZPackage();
				val.Write(HomesteadYaml.Serialize(value));
				ZRoutedRpc.instance.InvokeRoutedRPC(sender, "sighsorry.Homestead_BlueprintChestCommandResult", new object[1] { val });
			}
		}

		private static void RPC_HandleResult(long sender, ZPackage package)
		{
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
			{
				return;
			}
			try
			{
				ShowResult(HomesteadYaml.Deserialize<BlueprintChestCommandResult>(package.ReadString()), (Terminal?)(object)Console.instance);
			}
			catch (Exception arg)
			{
				_logger.LogError((object)$"Blueprint chest command result RPC failed: {arg}");
			}
		}

		private static BlueprintChestCommandResult Execute(BlueprintChestCommandRequest request)
		{
			if (ZDOMan.instance == null)
			{
				return BlueprintChestCommandResult.Fail("World is not ready.");
			}
			List<ZDO> list = ZoneBlueprintChestZdoRegistry.EnumerateChestZdos().ToList();
			if (list.Count == 0)
			{
				list = ZDOMan.instance.m_objectsByID.Values.Where((ZDO zdo) => zdo != null && zdo.IsValid() && TryGetChestKind(zdo, out var _)).ToList();
			}
			BlueprintChestCommandResult blueprintChestCommandResult = new BlueprintChestCommandResult
			{
				Success = true,
				DryRun = request.DryRun
			};
			foreach (ZDO item in list)
			{
				if (!TryGetChestKind(item, out var kind))
				{
					continue;
				}
				blueprintChestCommandResult.Total++;
				switch (kind)
				{
				case BlueprintChestKind.Build:
					blueprintChestCommandResult.Build++;
					break;
				case BlueprintChestKind.StorePrice:
					blueprintChestCommandResult.StorePrice++;
					if (!request.DryRun && TryCleanupOwnedDraft(item))
					{
						blueprintChestCommandResult.DraftFilesDeleted++;
					}
					break;
				case BlueprintChestKind.StorePurchase:
					blueprintChestCommandResult.StorePurchase++;
					break;
				case BlueprintChestKind.StorePayout:
					blueprintChestCommandResult.StorePayout++;
					break;
				}
				if (!request.DryRun)
				{
					SavedZdoHelper.Destroy(item);
					blueprintChestCommandResult.Deleted++;
				}
			}
			if (!request.DryRun)
			{
				SavedZdoHelper.FlushDestroyed();
			}
			blueprintChestCommandResult.Message = BuildMessage(blueprintChestCommandResult);
			return blueprintChestCommandResult;
		}

		private static bool TryGetChestKind(ZDO zdo, out BlueprintChestKind kind)
		{
			kind = BlueprintChestKind.Build;
			int prefab = zdo.GetPrefab();
			if (prefab == ZoneBlueprintPlanChestPrefab.PrefabHash)
			{
				kind = BlueprintChestKind.Build;
				return true;
			}
			if (prefab == ZoneBlueprintStoreChestPrefab.PricePrefabHash)
			{
				kind = BlueprintChestKind.StorePrice;
				return true;
			}
			if (prefab == ZoneBlueprintStoreChestPrefab.PurchasePrefabHash)
			{
				kind = BlueprintChestKind.StorePurchase;
				return true;
			}
			if (prefab == ZoneBlueprintStoreChestPrefab.PayoutPrefabHash)
			{
				kind = BlueprintChestKind.StorePayout;
				return true;
			}
			return false;
		}

		private static bool TryCleanupOwnedDraft(ZDO zdo)
		{
			if (!string.Equals(zdo.GetString("hs_store_mode", ""), "price", StringComparison.Ordinal) || zdo.GetBool("hs_store_confirmed", false) || !zdo.GetBool("hs_store_draft_owned_by_chest", false))
			{
				return false;
			}
			string @string = zdo.GetString("hs_store_blueprint_file", "");
			ZoneBlueprintStoreDraftRepository.DeleteFile(@string);
			zdo.Set("hs_store_draft_owned_by_chest", false);
			ZoneBlueprintChestZdoRegistry.Refresh(zdo);
			return !string.IsNullOrWhiteSpace(@string);
		}

		private static string BuildMessage(BlueprintChestCommandResult result)
		{
			string text = (result.DryRun ? "Found" : "Deleted");
			return $"{text} {result.Total} Homestead blueprint chest(s): build={result.Build}, price={result.StorePrice}, purchase={result.StorePurchase}, payout={result.StorePayout}, draft files deleted={result.DraftFilesDeleted}.";
		}

		private static void EnsureCommandReady()
		{
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				throw new InvalidOperationException("World is not ready.");
			}
			if (!ZNet.instance.IsServer() && ZRoutedRpc.instance == null)
			{
				throw new InvalidOperationException("Server RPC is not ready.");
			}
			if ((!ZNet.instance.IsServer() || !((Object)(object)Player.m_localPlayer == (Object)null)) && !ZNet.instance.LocalPlayerIsAdminOrHost())
			{
				throw new InvalidOperationException("Admin only.");
			}
		}

		private static bool IsAuthorizedSender(long sender)
		{
			ZNetPeer peer = ZNet.instance.GetPeer(sender);
			object obj;
			if (peer == null)
			{
				obj = null;
			}
			else
			{
				ZRpc rpc = peer.m_rpc;
				if (rpc == null)
				{
					obj = null;
				}
				else
				{
					ISocket socket = rpc.m_socket;
					obj = ((socket != null) ? socket.GetHostName() : null);
				}
			}
			if (obj == null)
			{
				obj = "";
			}
			string text = (string)obj;
			if (text.Length > 0)
			{
				return ZNet.instance.IsAdmin(text);
			}
			return false;
		}

		private static void ShowResult(BlueprintChestCommandResult result, Terminal? terminal)
		{
			string message = result.Message;
			_logger.LogInfo((object)message);
			if (terminal != null)
			{
				terminal.AddString(message);
			}
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer != null)
			{
				((Character)localPlayer).Message((MessageType)(result.Success ? 1 : 2), message, 0, (Sprite)null);
			}
		}
	}
	internal static class ZoneBlueprintChestInventoryScroll
	{
		[HarmonyPatch(typeof(InventoryGui), "Show")]
		private static class InventoryGuiShowPatch
		{
			private static void Postfix(InventoryGui __instance, Container container)
			{
				Request(container, ((Object)(object)__instance != (Object)null) ? __instance.m_containerGrid : null);
			}
		}

		private const int KeepTopFrames = 3;

		private static Container? _container;

		private static int _untilFrame;

		public static void TryKeepContainerGridAtTop(InventoryGrid? grid)
		{
			InventoryGui instance = InventoryGui.instance;
			if (!((Object)(object)instance == (Object)null) && !((Object)(object)grid == (Object)null) && !((Object)(object)instance.m_containerGrid != (Object)(object)grid) && ShouldKeepAtTop(instance.m_currentContainer) && Time.frameCount <= _untilFrame && !((Object)(object)_container != (Object)(object)instance.m_currentContainer))
			{
				ScrollToTop(grid);
			}
		}

		private static void Request(Container? container, InventoryGrid? grid)
		{
			if (ShouldKeepAtTop(container))
			{
				_container = container;
				_untilFrame = Time.frameCount + 3;
				ScrollToTop(grid);
			}
		}

		private static bool ShouldKeepAtTop(Container? container)
		{
			if (!Object.op_Implicit((Object)(object)container))
			{
				return false;
			}
			if (ZoneBlueprintPlanAnchor.TryGetAnchor(container, out ZoneBlueprintPlanAnchor _))
			{
				return true;
			}
			if (ZoneBlueprintStoreChestPatchHelper.TryGetStoreChest(container, out ZoneBlueprintStoreChest chest))
			{
				if (!chest.IsPurchaseChest())
				{
					return chest.IsPayoutChest();
				}
				return true;
			}
			return false;
		}

		private static void ScrollToTop(InventoryGrid? grid)
		{
			if (!((Object)(object)grid == (Object)null))
			{
				grid.ResetView();
				if ((Object)(object)grid.m_scrollbar != (Object)null)
				{
					grid.m_scrollbar.value = 1f;
				}
			}
		}
	}
	internal sealed class ZoneBlueprintPlanAnchor : MonoBehaviour
	{
		private sealed class RefundMaterial
		{
			public string ItemName { get; set; } = "";


			public string PrefabName { get; set; } = "";


			public int Amount { get; set; }
		}

		[HarmonyPatch(typeof(Container), "GetHoverText")]
		private static class ContainerGetHoverTextPatch
		{
			private static bool Prefix(Container __instance, ref string __result)
			{
				ZoneBlueprintPlanAnchor component = ((Component)__instance).GetComponent<ZoneBlueprintPlanAnchor>();
				if ((Object)(object)component == (Object)null)
				{
					return true;
				}
				__result = component.GetPlanHoverText();
				return false;
			}
		}

		[HarmonyPatch(typeof(Container), "Interact")]
		private static class ContainerInteractPatch
		{
			private static bool Prefix(Container __instance, Humanoid character, bool hold, ref bool __result)
			{
				//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)
				ZoneBlueprintPlanAnchor component = ((Component)__instance).GetComponent<ZoneBlueprintPlanAnchor>();
				if (!((Object)(object)component == (Object)null || hold))
				{
					Player val = (Player)(object)((character is Player) ? character : null);
					if (val != null)
					{
						KeyboardShortcut chestConfirmHotkey = BlueprintConfig.ChestConfirmHotkey;
						if (((KeyboardShortcut)(ref chestConfirmHotkey)).IsDown())
						{
							_lastConfirmInputFrame = Time.frameCount;
							__result = component.TryConfirm(val);
							return false;
						}
						if (BlueprintConfig.AzuCraftyBoxesPullOnOpen)
						{
							component.TryPullAvailableMaterials(val, "open", message: true);
						}
						component.Touch();
						return true;
					}
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(Player), "Update")]
		private static class PlayerUpdatePatch
		{
			private static void Postfix(Player __instance)
			{
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				if (Time.frameCount == _lastConfirmInputFrame || (Object)(object)__instance == (Object)null || (Object)(object)__instance != (Object)(object)Player.m_localPlayer || !((Character)__instance).TakeInput() || ((Character)__instance).IsDead())
				{
					return;
				}
				KeyboardShortcut chestConfirmHotkey = BlueprintConfig.ChestConfirmHotkey;
				if (!((KeyboardShortcut)(ref chestConfirmHotkey)).IsDown())
				{
					return;
				}
				GameObject hoverObject = ((Humanoid)__instance).GetHoverObject();
				if (!((Object)(object)hoverObject == (Object)null))
				{
					ZoneBlueprintPlanAnchor componentInParent = hoverObject.GetComponentInParent<ZoneBlueprintPlanAnchor>();
					if (!((Object)(object)componentInParent == (Object)null))
					{
						_lastConfirmInputFrame = Time.frameCount;
						componentInParent.TryConfirm(__instance);
					}
				}
			}
		}

		[HarmonyPatch(typeof(InventoryGrid), "UpdateGui")]
		private static class InventoryGridUpdateGuiPatch
		{
			private static void Postfix(InventoryGrid __instance)
			{
				ZoneBlueprintChestInventoryScroll.TryKeepContainerGridAtTop(__instance);
				InventoryGui instance = InventoryGui.instance;
				if (!((Object)(object)instance == (Object)null) && !((Object)(object)instance.m_containerGrid != (Object)(object)__instance) && TryGetAnchor(instance.m_currentContainer, out ZoneBlueprintPlanAnchor anchor))
				{
					anchor.DrawRequirementOverlay(__instance);
				}
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "OnSelectedItem")]
		private static class InventoryGuiOnSelectedItemPatch
		{
			private static bool Prefix(InventoryGui __instance, InventoryGrid grid, ItemData item, Vector2i pos, Modifier mod)
			{
				//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00be: Invalid comparison between Unknown and I4
				if ((Object)(object)__instance == (Object)null || (Object)(object)grid == (Object)null || !TryGetAnchor(__instance.m_currentContainer, out ZoneBlueprintPlanAnchor anchor))
				{
					return true;
				}
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer == (Object)null || ((Character)localPlayer).IsTeleporting())
				{
					return true;
				}
				Inventory inventory = __instance.m_currentContainer.GetInventory();
				bool flag = grid.GetInventory() == inventory;
				if (Object.op_Implicit((Object)(object)__instance.m_dragGo))
				{
					if (!flag || __instance.m_dragInventory == inventory)
					{
						return true;
					}
					if (__instance.m_dragItem != null && !__instance.m_dragItem.m_shared.m_questItem)
					{
						anchor.TryAcceptMaterialFromInventory(__instance.m_dragInventory, __instance.m_dragItem, __instance.m_dragAmount, message: true);
					}
					__instance.SetupDragItem((ItemData)null, (Inventory)null, 1);
					__instance.UpdateCraftingPanel(false);
					return false;
				}
				if (item == null)
				{
					return !flag;
				}
				if ((int)mod == 2 && !flag && !item.m_shared.m_questItem)
				{
					anchor.TryAcceptMaterialFromInventory(grid.GetInventory(), item, item.m_stack, message: true);
					__instance.UpdateCraftingPanel(false);
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "OnStackAll")]
		private static class InventoryGuiOnStackAllPatch
		{
			private static bool Prefix(InventoryGui __instance)
			{
				if ((Object)(object)__instance == (Object)null || !TryGetAnchor(__instance.m_currentContainer, out ZoneBlueprintPlanAnchor anchor) || (Object)(object)Player.m_localPlayer == (Object)null)
				{
					return true;
				}
				__instance.SetupDragItem((ItemData)null, (Inventory)null, 1);
				anchor.TryAcceptAllFromPlayer(Player.m_localPlayer);
				return false;
			}
		}

		[HarmonyPatch(typeof(Container), "StackAll")]
		private static class ContainerStackAllPatch
		{
			private static bool Prefix(Container __instance)
			{
				if (!TryGetAnchor(__instance, out ZoneBlueprintPlanAnchor anchor) || (Object)(object)Player.m_localPlayer == (Object)null)
				{
					return true;
				}
				anchor.TryAcceptAllFromPlayer(Player.m_localPlayer);
				return false;
			}
		}

		[HarmonyPatch(typeof(WearNTear), "Destroy")]
		private static class WearNTearDestroyPatch
		{
			private static void Prefix(WearNTear __instance)
			{
				ZoneBlueprintPlanAnchor component = ((Component)__instance).GetComponent<ZoneBlueprintPlanAnchor>();
				if (!((Object)(object)component == (Object)null))
				{
					component.ReleaseAzuCraftyBoxesContainer("PlanChest.WearNTear.Destroy prefix");
					component.TryRefundDepositedMaterials("WearNTear.Destroy prefix");
				}
			}
		}

		[HarmonyPatch(typeof(ZNetScene), "Destroy")]
		private static class ZNetSceneDestroyPatch
		{
			private static void Prefix(GameObject go)
			{
				if (Object.op_Implicit((Object)(object)go))
				{
					ZoneBlueprintPlanAnchor component = go.GetComponent<ZoneBlueprintPlanAnchor>();
					if (!((Object)(object)component == (Object)null))
					{
						component.ReleaseAzuCraftyBoxesContainer("PlanChest.ZNetScene.Destroy prefix");
						component.TryRefundDepositedMaterials("ZNetScene.Destroy prefix");
					}
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass45_0
		{
			public HomesteadCommandResult result;

			internal void <ConfirmAsync>b__0(HomesteadCommandResult value)
			{
				result = value;
			}
		}

		[CompilerGenerated]
		private sealed class <ConfirmAsync>d__45 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public string name;

			public Player player;

			public Vector3 anchorPosition;

			public Quaternion anchorRotation;

			public Dictionary<string, int> deposited;

			public ZoneBlueprintPlanAnchor <>4__this;

			private <>c__DisplayClass45_0 <>8__1;

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

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

			[DebuggerHidden]
			public <ConfirmAsync>d__45(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//IL_0051: 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)
				int num = <>1__state;
				ZoneBlueprintPlanAnchor zoneBlueprintPlanAnchor = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass45_0();
					<>8__1.result = HomesteadCommandResult.Fail(HomesteadLocalization.Text("hs_blueprint_confirmation_incomplete"));
					<>2__current = ZoneBlueprintCommands.FinalizeBlueprintPlanAsync(name, player, anchorPosition, anchorRotation, deposited, delegate(HomesteadCommandResult value)
					{
						<>8__1.result = value;
					});
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					zoneBlueprintPlanAnchor._confirmInProgress = false;
					Message(player, <>8__1.result.Message, (MessageType)(<>8__1.result.Success ? 1 : 2));
					if (!<>8__1.result.Success)
					{
						return false;
					}
					if ((Object)(object)zoneBlueprintPlanAnchor._nview == (Object)null || !zoneBlueprintPlanAnchor._nview.IsValid())
					{
						return false;
					}
					zoneBlueprintPlanAnchor.PlayConfirmSfx();
					zoneBlueprintPlanAnchor._nview.GetZDO().Set("hs_plan_confirmed", true);
					zoneBlueprintPlanAnchor.ClearDepositedMaterials();
					zoneBlueprintPlanAnchor._nview.Destroy();
					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();
			}
		}

		[CompilerGenerated]
		private sealed class <DropRefundMaterialsDeferred>d__103 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public List<RefundMaterial> refundMaterials;

			public Vector3 dropPosition;

			public string source;

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

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

			[DebuggerHidden]
			public <DropRefundMaterialsDeferred>d__103(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Expected O, but got Unknown
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					DropRefundMaterials(refundMaterials, dropPosition, source);
					return false;
				}
			}

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

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

		private const string BlueprintNameKey = "hs_blueprint_name";

		private const string AnchorXKey = "hs_anchor_x";

		private const string AnchorYKey = "hs_anchor_y";

		private const string AnchorZKey = "hs_anchor_z";

		private const string AnchorRotXKey = "hs_anchor_rot_x";

		private const string AnchorRotYKey = "hs_anchor_rot_y";

		private const string AnchorRotZKey = "hs_anchor_rot_z";

		private const string AnchorRotWKey = "hs_anchor_rot_w";

		private const string ConfirmedKey = "hs_plan_confirmed";

		private const string MaterialPrefix = "hs_plan_material_";

		private const string RefundPayloadKey = "hs_plan_refund_payload";

		private const int RefundPayloadVersion = 1;

		private const string ProgressSfxPrefab = "sfx_build_hammer_wood";

		private const string ConfirmSfxPrefab = "vfx_StaminaUpgrade";

		private const float CleanupCheckInterval = 30f;

		private const float FailedPlanReloadRetryInterval = 5f;

		private const float FailedPlanWarningInterval = 60f;

		private static int _lastConfirmInputFrame = -1;

		private ZNetView? _nview;

		private Container? _container;

		private WearNTear? _wearNTear;

		private ZoneBlueprintFile? _blueprint;

		private ZoneBlueprintCommands.BlueprintLoadPlan? _plan;

		private List<ZoneBlueprintRequirement> _requirements = new List<ZoneBlueprintRequirement>();

		private List<ZoneBlueprintCraftingStationRequirement> _stationRequirements = new List<ZoneBlueprintCraftingStationRequirement>();

		private string _loadedBlueprintName = "";

		private readonly ZoneBlueprintGhostOwner _previewGhost = new ZoneBlueprintGhostOwner();

		private readonly ZoneBlueprintGhostOwner _stationGhost = new ZoneBlueprintGhostOwner();

		private bool _absorbing;

		private bool _refundStarted;

		private bool _confirmInProgress;

		private string _lastReadySignature = "";

		private string _lastPreviewStyleSignature = "";

		private string _failedBlueprintName = "";

		private string _lastPlanLoadFailure = "";

		private int _lastInventorySignatureHash;

		private bool _hasInventorySignature;

		private float _nextCleanupCheck;

		private float _nextFailedPlanReloadAt;

		private float _nextFailedPlanWarningAt;

		private void Awake()
		{
			_nview = ((Component)this).GetComponent<ZNetView>();
			_container = ((Component)this).GetComponent<Container>();
			_wearNTear = ((Component)this).GetComponent<WearNTear>();
			if ((Object)(object)_wearNTear != (Object)null)
			{
				WearNTear? wearNTear = _wearNTear;
				wearNTear.m_onDestroyed = (Action)Delegate.Combine(wearNTear.m_onDestroyed, new Action(OnDestroyed));
			}
			ZoneBlueprintChestZdoRegistry.Refresh(((Object)(object)_nview != (Object)null && _nview.IsValid()) ? _nview.GetZDO() : null);
			((MonoBehaviour)this).InvokeRepeating("Tick", 0.5f, 0.5f);
		}

		private void OnDestroy()
		{
			ReleaseAzuCraftyBoxesContainer("PlanChest.OnDestroy");
			TryRefundDepositedMaterials("Unity.OnDestroy");
			ClearPreview();
		}

		public void SetPlan(string blueprintName, Vector3 anchor, Quaternion anchorRotation)
		{
			//IL_0039: 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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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_009f: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_nview == (Object)null) && _nview.IsValid())
			{
				ZDO zDO = _nview.GetZDO();
				zDO.Set("hs_blueprint_name", blueprintName);
				zDO.Set("hs_anchor_x", anchor.x);
				zDO.Set("hs_anchor_y", anchor.y);
				zDO.Set("hs_anchor_z", anchor.z);
				zDO.Set("hs_anchor_rot_x", anchorRotation.x);
				zDO.Set("hs_anchor_rot_y", anchorRotation.y);
				zDO.Set("hs_anchor_rot_z", anchorRotation.z);
				zDO.Set("hs_anchor_rot_w", anchorRotation.w);
				zDO.Set("hs_plan_confirmed", false);
				ZoneBlueprintChestLifecycle.Initialize(zDO);
				ReloadPlan(force: true);
				RebuildPreview();
			}
		}

		public string GetPlanHoverText()
		{
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			string blueprintName = GetBlueprintName();
			if (!ReloadPlan())
			{
				return HomesteadLocalization.MaybeLocalize(HomesteadLocalization.Text("hs_blueprint_chest_data_missing"));
			}
			int requiredTotal = GetRequiredTotal();
			int depositedTotal = GetDepositedTotal();
			bool flag = requiredTotal == 0 || depositedTotal >= requiredTotal;
			string text = HomesteadLocalization.Format("hs_blueprint_chest_header", blueprintName, depositedTotal, requiredTotal);
			text = text + HomesteadLocalization.Format("hs_hover_action", "$KEY_Use", HomesteadLocalization.Text("hs_blueprint_open_materials")) + "\n";
			text = text + HomesteadLocalization.Format("hs_hover_action", FormatShortcut(BlueprintConfig.ChestConfirmHotkey), HomesteadLocalization.Text("hs_blueprint_confirm_build")) + "\n";
			if (!flag)
			{
				text = text + "\n" + HomesteadLocalization.Text("hs_blueprint_missing") + "\n";
				foreach (ZoneBlueprintRequirement item in GetMissingRequirements().Take(6))
				{
					text += $" <color=yellow>{item.Amount}</color> {Localization.instance.Localize(item.DisplayName)}\n";
				}
			}
			return Localization.instance.Localize(text);
		}

		public bool TryConfirm(Player player)
		{
			//IL_0103: 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)
			if ((Object)(object)_nview == (Object)null || !_nview.IsValid())
			{
				return true;
			}
			_nview.ClaimOwnership();
			Touch();
			Tick();
			long @long = _nview.GetZDO().GetLong(ZDOVars.s_creator, 0L);
			if (@long != 0L && player.GetPlayerID() != @long)
			{
				Message(player, HomesteadLocalization.Text("hs_blueprint_other_creator"), (MessageType)2);
				return true;
			}
			string blueprintName = GetBlueprintName();
			if (!ReloadPlan())
			{
				Message(player, HomesteadLocalization.Format("hs_blueprint_not_available", blueprintName), (MessageType)2);
				return true;
			}
			if (BlueprintConfig.AzuCraftyBoxesPullOnConfirm)
			{
				TryPullAvailableMaterials(player, "confirm", message: true);
			}
			Dictionary<string, int> depositedMaterials = GetDepositedMaterials();
			if (_confirmInProgress)
			{
				Message(player, HomesteadLocalization.Text("hs_blueprint_confirmation_in_progress"), (MessageType)2);
				return true;
			}
			if (!TryGetAnchorTransform(out var position, out var rotation))
			{
				Message(player, HomesteadLocalization.Format("hs_blueprint_not_available", blueprintName), (MessageType)2);
				return true;
			}
			_confirmInProgress = true;
			((MonoBehaviour)this).StartCoroutine(ConfirmAsync(player, blueprintName, position, rotation, depositedMaterials));
			return true;
		}

		[IteratorStateMachine(typeof(<ConfirmAsync>d__45))]
		private IEnumerator ConfirmAsync(Player player, string name, Vector3 anchorPosition, Quaternion anchorRotation, Dictionary<string, int> deposited)
		{
			//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_0023: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ConfirmAsync>d__45(0)
			{
				<>4__this = this,
				player = player,
				name = name,
				anchorPosition = anchorPosition,
				anchorRotation = anchorRotation,
				deposited = deposited
			};
		}

		private void Tick()
		{
			if (!((Object)(object)_nview == (Object)null) && _nview.IsValid() && ReloadPlan())
			{
				if (_nview.IsOwner())
				{
					AbsorbContainerMaterials();
					TouchWhenInventoryChanged();
					CheckAutoCleanup();
				}
				UpdatePreview();
			}
		}

		public void Touch()
		{
			ZoneBlueprintChestLifecycle.Touch(_nview);
		}

		private void TouchWhenInventoryChanged()
		{
			int inventorySignatureHash = GetInventorySignatureHash();
			if (!_hasInventorySignature)
			{
				_lastInventorySignatureHash = inventorySignatureHash;
				_hasInventorySignature = true;
			}
			else if (inventorySignatureHash != _lastInventorySignatureHash)
			{
				_lastInventorySignatureHash = inventorySignatureHash;
				Touch();
			}
		}

		private void CheckAutoCleanup()
		{
			if (Time.time < _nextCleanupCheck)
			{
				return;
			}
			_nextCleanupCheck = Time.time + 30f;
			ZNetView? nview = _nview;
			if (ZoneBlueprintChestLifecycle.IsExpired((nview != null) ? nview.GetZDO() : null, BlueprintConfig.ChestTimeoutMinutes) && !HasRetainedMaterials())
			{
				ZNetView? nview2 = _nview;
				if (nview2 != null)
				{
					nview2.Destroy();
				}
			}
		}

		private bool HasRetainedMaterials()
		{
			Container? container = _container;
			int? obj;
			if (container == null)
			{
				obj = null;
			}
			else
			{
				Inventory inventory = container.m_inventory;
				obj = ((inventory != null) ? new int?(inventory.NrOfItems()) : null);
			}
			int? num = obj;
			if (num.GetValueOrDefault() > 0)
			{
				return true;
			}
			if (GetDepositedTotal() > 0)
			{
				return true;
			}
			return ReadRefundMaterials().Any((RefundMaterial material) => material.Amount > 0);
		}

		private int GetInventorySignatureHash()
		{
			Inventory val = _container?.m_inventory;
			if (val == null)
			{
				return 0;
			}
			int num = 17;
			int num2 = 0;
			foreach (ItemData allItem in val.GetAllItems())
			{
				string obj = allItem.m_shared?.m_name ?? "";
				int hashCode = StringComparer.Ordinal.GetHashCode(obj);
				hashCode = (hashCode * 397) ^ allItem.m_stack;
				num += hashCode;
				num ^= (hashCode << 7) | (hashCode >>> 25);
				num2++;
			}
			return (num * 397) ^ num2;
		}

		private bool ReloadPlan(bool force = false)
		{
			//IL_010a: 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_0096: 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)
			string blueprintName = GetBlueprintName();
			if (string.IsNullOrWhiteSpace(blueprintName))
			{
				return false;
			}
			if (!force && _plan != null && string.Equals(_loadedBlueprintName, blueprintName, StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			if (ShouldSkipFailedPlanReload(blueprintName, force))
			{
				return false;
			}
			if (!TryGetAnchorTransform(out var position, out var rotation))
			{
				_blueprint = null;
				_plan = null;
				_requirements = new List<ZoneBlueprintRequirement>();
				_stationRequirements = new List<ZoneBlueprintCraftingStationRequirement>();
				_loadedBlueprintName = "";
				_lastReadySignature = "";
				ClearPreview();
				return false;
			}
			ZoneBlueprintFile blueprint;
			try
			{
				_blueprint = ZoneBlueprintCommands.LoadBlueprintForPlan(blueprintName);
				_plan = ZoneBlueprintCommands.CreateLoadPlanForBlueprint(blueprintName, position, rotation);
				_requirements = ZoneBlueprintCommands.CollectRequirements(_plan);
				_stationRequirements = ZoneBlueprintCommands.CollectCraftingStations(_plan);
				_loadedBlueprintName = blueprintName;
				_lastReadySignature = "";
				ClearPlanLoadFailure();
				return true;
			}
			catch (Exception ex2) when (ZoneBlueprintPlanRpc.TryGetCachedPreview(blueprintName, out blueprint))
			{
				try
				{
					_blueprint = blueprint;
					_plan = ZoneBlueprintCommands.CreateLoadPlanForBlueprint(blueprint, position, rotation);
					_requirements = ZoneBlueprintCommands.CollectRequirements(_plan);
					_stationRequirements = ZoneBlueprintCommands.CollectCraftingStations(_plan);
					_loadedBlueprintName = blueprintName;
					_lastReadySignature = "";
					ClearPlanLoadFailure();
					return true;
				}
				catch (Exception ex)
				{
					RecordPlanLoadFailure(blueprintName, "Failed to load Homestead server blueprint preview '" + blueprintName + "': " + ex.Message + " (local: " + ex2.Message + ")", logWarning: true);
				}
				_blueprint = null;
				_plan = null;
				_requirements = new List<ZoneBlueprintRequirement>();
				_stationRequirements = new List<ZoneBlueprintCraftingStationRequirement>();
				_loadedBlueprintName = "";
				_lastReadySignature = "";
				ClearPreview();
				return false;
			}
			catch (Exception ex3)
			{
				ZoneBlueprintPlanRpc.RequestPreview(blueprintName);
				RecordPlanLoadFailure(blueprintName, "Failed to load Homestead blueprint plan '" + blueprintName + "': " + ex3.Message, !ZoneBlueprintPlanRpc.IsPreviewPending(blueprintName));
				_blueprint = null;
				_plan = null;
				_requirements = new List<ZoneBlueprintRequirement>();
				_stationRequirements = new List<ZoneBlueprintCraftingStationRequirement>();
				_loadedBlueprintName = "";
				_lastReadySignature = "";
				ClearPreview();
				return false;
			}
		}

		private bool ShouldSkipFailedPlanReload(string name, bool force)
		{
			if (force || _plan != null || !string.Equals(_failedBlueprintName, name, StringComparison.OrdinalIgnoreCase))
			{
				return false;
			}
			return Time.realtimeSinceStartup < _nextFailedPlanReloadAt;
		}

		private void RecordPlanLoadFailure(string name, string message, bool logWarning)
		{
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			bool flag = !string.Equals(_lastPlanLoadFailure, message, StringComparison.Ordinal);
			_failedBlueprintName = name;
			_lastPlanLoadFailure = message;
			_nextFailedPlanReloadAt = realtimeSinceStartup + 5f;
			if (logWarning && (flag || !(realtimeSinceStartup < _nextFailedPlanWarningAt)))
			{
				HomesteadPlugin.HomesteadLogger.LogWarning((object)message);
				_nextFailedPlanWarningAt = realtimeSinceStartup + 60f;
			}
		}

		private void ClearPlanLoadFailure()
		{
			_failedBlueprintName = "";
			_lastPlanLoadFailure = "";
			_nextFailedPlanReloadAt = 0f;
			_nextFailedPlanWarningAt = 0f;
		}

		private void AbsorbContainerMaterials()
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			if (_container?.m_inventory != null && !_absorbing && _container.m_inventory.GetAllItems().ToList().Count != 0)
			{
				string readyBefore = CaptureReadySignature();
				_absorbing = true;
				ZoneMaterialEscrow.AbsorbResult absorbResult;
				try
				{
					absorbResult = CreateMaterialSession().AbsorbUnexpectedInventoryItems(_container.m_inventory, ((Component)this).transform.position, preferInventory: false);
				}
				finally
				{
					_absorbing = false;
				}
				if (absorbResult.Changed)
				{
					_container.Save();
					_lastReadySignature = "";
					Touch();
					PlayProgressSfxIfReadyAdvanced(readyBefore, absorbResult.Accepted);
				}
			}
		}

		public bool TryAcceptMaterialFromInventory(Inventory sourceInventory, ItemData item, int requestedAmount, bool message)
		{
			string readyBefore = CaptureReadySignature();
			int num = AcceptMaterialFromInventory(sourceInventory, item, requestedAmount);
			if (num > 0)
			{
				Container? container = _container;
				if (container != null)
				{
					container.Save();
				}
				_lastReadySignature = "";
				Touch();
				PlayProgressSfxIfReadyAdvanced(readyBefore, num);
				if (message && (Object)(object)Player.m_localPlayer != (Object)null && num < requestedAmount)
				{
					((Character)Player.m_localPlayer).Message((MessageType)2, HomesteadLocalization.Format("hs_blueprint_accepted_excess_inventory", num), 0, (Sprite)null);
				}
				return true;
			}
			if (message && (Object)(object)Player.m_localPlayer != (Object)null)
			{
				((Character)Player.m_localPlayer).Message((MessageType)2, HomesteadLocalization.Text("hs_blueprint_material_not_needed"), 0, (Sprite)null);
			}
			return false;
		}

		public bool TryAcceptAllFromPlayer(Player player)
		{
			Player player2 = player;
			if ((Object)(object)player2 == (Object)null)
			{
				return false;
			}
			Inventory inventory = ((Humanoid)player2).GetInventory();
			string readyBefore = CaptureReadySignature();
			int num = 0;
			num += CreateMaterialSession().AcceptAllNeeded(inventory, (ItemData item) => item.m_shared.m_questItem || ((Humanoid)player2).IsItemEquiped(item));
			if (num > 0)
			{
				Container? container = _container;
				if (container != null)
				{
					container.Save();
				}
				_lastReadySignature = "";
				Touch();
				PlayProgressSfxIfReadyAdvanced(readyBefore, num);
				((Character)player2).Message((MessageType)2, HomesteadLocalization.Format("hs_blueprint_accepted_materials", num), 0, (Sprite)null);
				return true;
			}
			((Character)player2).Message((MessageType)2, HomesteadLocalization.Text("hs_blueprint_no_matching_materials"), 0, (Sprite)null);
			return false;
		}

		public int TryPullAvailableMaterials(Player player, string trigger, bool message)
		{
			if ((Object)(object)player == (Object)null || (Object)(object)_nview == (Object)null || !_nview.IsValid() || !ReloadPlan())
			{
				return 0;
			}
			string readyBefore = CaptureReadySignature();
			int num = AcceptAllFromPlayerInventory(player);
			int num2 = 0;
			if ((trigger == "confirm" && BlueprintConfig.AzuCraftyBoxesPullOnConfirm) || (trigger == "open" && BlueprintConfig.AzuCraftyBoxesPullOnOpen))
			{
				num2 = TryPullFromAzuCraftyBoxes(player, trigger, message: false, playProgressSfx: false);
			}
			int num3 = num + num2;
			if (num3 > 0)
			{
				Container? container = _container;
				if (container != null)
				{
					container.Save();
				}
				_lastReadySignature = "";
				Touch();
				PlayProgressSfxIfReadyAdvanced(readyBefore, num3);
				if (message)
				{
					((Character)player).Message((MessageType)1, HomesteadLocalization.Format("hs_blueprint_pulled_materials", num3, num, num2), 0, (Sprite)null);
				}
			}
			return num3;
		}

		public int TryPullFromAzuCraftyBoxes(Player player, string trigger, bool message, bool playProgressSfx = true)
		{
			if ((Object)(object)_nview == (Object)null || !_nview.IsValid() || !ReloadPlan())
			{
				return 0;
			}
			ZoneMaterialEscrow.Session session = CreateMaterialSession();
			List<ZoneBlueprintRequirement> missingRequirements = session.GetMissingRequirements();
			if (missingRequirements.Count == 0)
			{
				return 0;
			}
			string readyBefore = (playProgressSfx ? CaptureReadySignature() : "");
			int num = AzuCraftyBoxesCompat.PullMissingMaterials((Component)(object)this, missingRequirements, delegate(ZoneBlueprintRequirement requirement, int amount)
			{
				session.AcceptPulled(requirement, amount);
			});
			if (num <= 0)
			{
				return 0;
			}
			Container? container = _container;
			if (container != null)
			{
				container.Save();
			}
			_lastReadySignature = "";
			Touch();
			if (playProgressSfx)
			{
				PlayProgressSfxIfReadyAdvanced(readyBefore, num);
			}
			if (message)
			{
				((Character)player).Message((MessageType)1, HomesteadLocalization.Format("hs_blueprint_pulled_from_containers", num), 0, (Sprite)null);
			}
			return num;
		}

		private int AcceptAllFromPlayerInventory(Player player)
		{
			Player player2 = player;
			Inventory inventory = ((Humanoid)player2).GetInventory();
			return CreateMaterialSession().AcceptAllNeeded(inventory, (ItemData item) => item.m_shared.m_questItem || ((Humanoid)player2).IsItemEquiped(item));
		}

		private int AcceptMaterialFromInventory(Inventory sourceInventory, ItemData item, int requestedAmount)
		{
			if ((Object)(object)_nview == (Object)null || !_nview.IsValid() || sourceInventory == null || item == null || requestedAmount <= 0)
			{
				return 0;
			}
			return CreateMaterialSession().AcceptNeededOnly(sourceInventory, item, requestedAmount);
		}

		private void AcceptMaterialAmount(ZoneBlueprintRequirement requirement, int amount)
		{
			if (amount > 0)
			{
				SetDeposited(requirement.ItemName, GetDeposited(requirement.ItemName) + amount);
				AddRefundMaterial(requirement, amount);
			}
		}

		private void PlayConfirmSfx()
		{
			PlayLocalEffect("vfx_StaminaUpgrade", "confirm");
		}

		private void PlayProgressSfxIfReadyAdvanced(string readyBefore, int acceptedAmount)
		{
			if (acceptedAmount > 0)
			{
				string b = CaptureReadySignature();
				if (!string.Equals(readyBefore, b, StringComparison.Ordinal))
				{
					PlayLocalEffect("sfx_build_hammer_wood", "progress");
				}
			}
		}

		private string CaptureReadySignature()
		{
			if (_plan == null && !ReloadPlan())
			{
				return "";
			}
			GetReadyEntryIndices(out string signature);
			return signature;
		}

		private void PlayLocalEffect(string prefabName, string label)
		{
			//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)
			if (!((Object)(object)Player.m_localPlayer == (Object)null))
			{
				GameObject val = FindPrefab(prefabName);
				if (Object.op_Implicit((Object)(object)val))
				{
					Object.Instantiate<GameObject>(val, ((Component)this).transform.position, Quaternion.identity);
				}
			}
		}

		private static void GiveOrDropItem(ItemData prototype, int amount, Vector3 dropPosition, bool preferInventory, GameObject? dropPrefab = null)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			ZoneMaterialEscrow.GiveOrDropItem(prototype, amount, dropPosition, preferInventory, dropPrefab);
		}

		private void UpdatePreview()
		{
			//IL_006e: 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_0063: 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)
			if ((Object)(object)Player.m_localPlayer == (Object)null || _blueprint == null || _plan == null)
			{
				return;
			}
			RefreshPendingMaterialStyle();
			if (!TryGetAnchorTransform(out var position, out var rotation))
			{
				ClearPreview();
				return;
			}
			string signature;
			HashSet<int> readyEntryIndices = GetReadyEntryIndices(out signature);
			if (_previewGhost.HasRoot && string.Equals(signature, _lastReadySignature, StringComparison.Ordinal))
			{
				_previewGhost.SetTransform(position, rotation);
			}
			else
			{
				RebuildPreview(readyEntryIndices, signature, position, rotation);
			}
		}

		private void RebuildPreview(HashSet<int>? readyEntries = null, string? readySignature = null, Vector3? anchorPosition = null, Quaternion? anchorRotation = null)
		{
			//IL_0020: 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_0055: 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_005b: 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_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_009e: 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)
			if ((Object)(object)Player.m_localPlayer == (Object)null || _blueprint == null || _plan == null)
			{
				return;
			}
			Vector3 position = default(Vector3);
			Quaternion rotation = default(Quaternion);
			if ((!anchorPosition.HasValue || !anchorRotation.HasValue) && !TryGetAnchorTransform(out position, out rotation))
			{
				ClearPreview();
				return;
			}
			Vector3 valueOrDefault = anchorPosition.GetValueOrDefault(position);
			Quaternion valueOrDefault2 = anchorRotation.GetValueOrDefault(rotation);
			if (readyEntries == null)
			{
				readyEntries = GetReadyEntryIndices(out readySignature);
			}
			if (readySignature == null)
			{
				readySignature = "";
			}
			ClearPreview();
			GameObject val = _previewGhost.CreateBlueprint(_blueprint, "HomesteadPlanPreview_" + GetBlueprintName(), valueOrDefault, valueOrDefault2);
			for (int i = 0; i < val.transform.childCount; i++)
			{
				Transform child = val.transform.GetChild(i);
				if (!readyEntries.Contains(i))
				{
					ApplyPendingMaterial(((Component)child).gameObject);
				}
			}
			RebuildStationPreview();
			_lastReadySignature = readySignature;
		}

		private void ClearPreview()
		{
			_previewGhost.Destroy();
			_stationGhost.Destroy();
		}

		private void RebuildStationPreview()
		{
			//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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: 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_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_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: 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_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: 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_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: 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_0173: Unknown result type (might be due to invalid IL or missing references)
			_stationGhost.Destroy();
			if (_blueprint == null || _stationRequirements.Count == 0)
			{
				return;
			}
			Vector3 position = ((Component)this).transform.position;
			Quaternion rotation = ((Component)this).transform.rotation;
			GameObject val = _stationGhost.CreateEmpty("HomesteadPlanStationPreview_" + GetBlueprintName());
			float num = 2.75f;
			float num2 = 360f / (float)Mathf.Max(1, _stationRequirements.Count);
			for (int i = 0; i < _stationRequirements.Count; i++)
			{
				ZoneBlueprintCraftingStationRequirement zoneBlueprintCraftingStationRequirement = _stationRequirements[i];
				GameObject val2 = FindPrefab(zoneBlueprintCraftingStationRequirement.PrefabName);
				if (Object.op_Implicit((Object)(object)val2))
				{
					Vector3 val3 = Quaternion.Euler(0f, num2 * (float)i, 0f) * new Vector3(0f, 0f, 0f - num);
					Vector3 val4 = position + rotation * val3;
					val4.y = SampleGroundY(val4.x, val4.z, position.y);
					GameObject val5 = ZoneBlueprintVisuals.CreatePrefabVisualRoot(val2, "HomesteadStationGhost_" + zoneBlueprintCraftingStationRequirement.PrefabName);
					val5.transform.SetParent(val.transform, true);
					val5.transform.position = val4;
					val5.transform.rotation = rotation * Quaternion.Euler(0f, 180f + num2 * (float)i, 0f);
					_stationGhost.ApplyMaterial(val5, BlueprintConfig.PreviewGhostColor);
				}
			}
		}

		private static GameObject? FindPrefab(string prefabName)
		{
			if (string.IsNullOrWhiteSpace(prefabName))
			{
				return null;
			}
			ZNetScene instance = ZNetScene.instance;
			object obj = ((instance != null) ? instance.GetPrefab(prefabName) : null);
			if (obj == null)
			{
				obj = PrefabManager.Instance.GetPrefab(prefabName);
				if (obj == null)
				{
					ObjectDB instance2 = ObjectDB.instance;
					if (instance2 == null)
					{
						return null;
					}
					obj = instance2.GetItemPrefab(prefabName);
				}
			}
			return (GameObject?)obj;
		}

		private static float SampleGroundY(float x, float z, float fallbackY)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ZoneSystem.instance == (Object)null)
			{
				return fallbackY;
			}
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(x, fallbackY, z);
			Vector3 val2 = default(Vector3);
			Biome val3 = default(Biome);
			BiomeArea val4 = default(BiomeArea);
			Heightmap val5 = default(Heightmap);
			ZoneSystem.instance.GetGroundData(ref val, ref val2, ref val3, ref val4, ref val5);
			return val.y;
		}

		private void ApplyPendingMaterial(GameObject root)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			_previewGhost.ApplyMaterial(root, BlueprintConfig.PreviewGhostColor);
		}

		private bool RefreshPendingMaterialStyle()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: 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_0036: Unknown result type (might be due to invalid IL or missing references)
			Color previewGhostColor = BlueprintConfig.PreviewGhostColor;
			string previewStyleSignature = GetPreviewStyleSignature(previewGhostColor);
			bool result = !string.Equals(previewStyleSignature, _lastPreviewStyleSignature, StringComparison.Ordinal);
			_lastPreviewStyleSignature = previewStyleSignature;
			_previewGhost.UpdateMaterialColor(previewGhostColor);
			_stationGhost.UpdateMaterialColor(previewGhostColor);
			return result;
		}

		private static string GetPreviewStyleSignature(Color color)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return ColorUtility.ToHtmlStringRGBA(color);
		}

		private HashSet<int> GetReadyEntryIndices(out string signature)
		{
			HashSet<int> hashSet = new HashSet<int>();
			if (_plan == null)
			{
				signature = "";
				return hashSet;
			}
			Dictionary<string, int> budget = GetDepositedMaterials();
			if (!TryGetAnchorTransform(out var anchor, out var _))
			{
				signature = "";
				return hashSet;
			}
			foreach (var item4 in (from item in _plan.Entries.Select((ZoneBlueprintCommands.BlueprintLoadEntry entry, int index) => (entry, index))
				orderby item.entry.Position.y
				select item).ThenBy<(ZoneBlueprintCommands.BlueprintLoadEntry, int), float>(delegate((ZoneBlueprintCommands.BlueprintLoadEntry entry, int index) item)
			{
				//IL_0006: 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_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: 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_002a: Unknown result type (might be due to invalid IL or missing references)
				Vector3 val = item.entry.Position - anchor;
				return val.x * val.x + val.z * val.z;
			}).ThenBy<(ZoneBlueprintCommands.BlueprintLoadEntry, int), int>(((ZoneBlueprintCommands.BlueprintLoadEntry entry, int index) item) => item.index))
			{
				ZoneBlueprintCommands.BlueprintLoadEntry item2 = item4.Item1;
				int item3 = item4.Item2;
				Dictionary<string, int> entryRequirements = GetEntryRequirements(item2);
				if (entryRequirements.Any((KeyValuePair<string, int> pair) => !budget.TryGetValue(pair.Key, out var value) || value < pair.Value))
				{
					continue;
				}
				foreach (KeyValuePair<string, int> item5 in entryRequirements)
				{
					budget[item5.Key] -= item5.Value;
				}
				hashSet.Add(item3);
			}
			signature = string.Join(",", hashSet.OrderBy((int index) => index));
			return hashSet;
		}

		private static Dictionary<string, int> GetEntryRequirements(ZoneBlueprintCommands.BlueprintLoadEntry entry)
		{
			Dictionary<string, int> dictionary = new Dictionary<string, int>();
			Piece component = entry.Prefab.GetComponent<Piece>();
			if ((Object)(object)component == (Object)null)
			{
				return dictionary;
			}
			Requirement[] resources = component.m_resources;
			foreach (Requirement val in resources)
			{
				if (Object.op_Implicit((Object)(object)val.m_resItem) && val.m_amount > 0)
				{
					string name = val.m_resItem.m_itemData.m_shared.m_name;
					dictionary.TryGetValue(name, out var value);
					dictionary[name] = value + val.GetAmount(0);
				}
			}
			return dictionary;
		}

		private IEnumerable<ZoneBlueprintRequirement> GetMissingRequirements()
		{
			return CreateMaterialSession().GetMissingRequirements();
		}

		public List<ZoneBlueprintRequirement> GetMissingRequirementList()
		{
			return GetMissingRequirements().ToList();
		}

		public bool IsComplete()
		{
			return GetDepositedTotal() >= GetRequiredTotal();
		}

		private int GetRequiredTotal()
		{
			return _requirements.Sum((ZoneBlueprintRequirement requirement) => requirement.Amount);
		}

		private int GetDepositedTotal()
		{
			return _requirements.Sum((ZoneBlueprintRequirement requirement) => Mathf.Min(requirement.Amount, GetDeposited(requirement.ItemName)));
		}

		private Dictionary<string, int> GetDepositedMaterials()
		{
			Dictionary<string, int> dictionary = new Dictionary<string, int>();
			foreach (ZoneBlueprintRequirement requirement in _requirements)
			{
				dictionary[requirement.ItemName] = GetDeposited(requirement.ItemName);
			}
			return dictionary;
		}

		private int GetDeposited(string itemName)
		{
			ZNetView? nview = _nview;
			if (((nview != null) ? nview.GetZDO() : null) == null)
			{
				return 0;
			}
			return _nview.GetZDO().GetInt("hs_plan_material_" + itemName, 0);
		}

		private ZoneMaterialEscrow.Session CreateMaterialSession()
		{
			return new ZoneMaterialEscrow.Session(_requirements, GetDeposited, AcceptMaterialAmount);
		}

		private void SetDeposited(string itemName, int amount)
		{
			ZNetView? nview = _nview;
			if (nview != null)
			{
				ZDO zDO = nview.GetZDO();
				if (zDO != null)
				{
					zDO.Set("hs_plan_material_" + itemName, Mathf.Max(0, amount));
				}
			}
		}

		private void ClearDepositedMaterials()
		{
			foreach (ZoneBlueprintRequirement requirement in _requirements)
			{
				SetDeposited(requirement.ItemName, 0);
			}
			ClearRefundMaterials();
		}

		private void AddRefundMaterial(ZoneBlueprintRequirement requirement, int amount)
		{
			ZoneBlueprintRequirement requirement2 = requirement;
			if (amount > 0)
			{
				ZNetView? nview = _nview;
				if (((nview != null) ? nview.GetZDO() : null) != null)
				{
					List<RefundMaterial> list = ReadRefundMaterials();
					RefundMaterial refundMaterial = list.FirstOrDefault((RefundMaterial item) => item.ItemName == requirement2.ItemName);
					if (refundMaterial == null)
					{
						refundMaterial = new RefundMaterial
						{
							ItemName = requirement2.ItemName,
							PrefabName = requirement2.PrefabName
						};
						list.Add(refundMaterial);
					}
					if (string.IsNullOrWhiteSpace(refundMaterial.PrefabName))
					{
						refundMaterial.PrefabName = requirement2.PrefabName;
					}
					refundMaterial.Amount += amount;
					WriteRefundMaterials(list);
					LogRefundInfo($"Recorded refund material: {requirement2.ItemName} prefab={refundMaterial.PrefabName} added={amount} total={refundMaterial.Amount}.");
					return;
				}
			}
			string itemName = requirement2.ItemName;
			object arg = amount;
			ZNetView? nview2 = _nview;
			LogRefundDebug($"Skipped refund ledger add for '{itemName}'. amount={arg}, zdo={((nview2 != null) ? nview2.GetZDO() : null) != null}.");
		}

		private List<RefundMaterial> ReadRefundMaterials()
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			ZNetView? nview = _nview;
			ZDO val = ((nview != null) ? nview.GetZDO() : null);
			if (val == null)
			{
				LogRefundDebug("Read refund ledger skipped: no ZDO.");
				return new List<RefundMaterial>();
			}
			string @string = val.GetString("hs_plan_refund_payload", "");
			if (string.IsNullOrWhiteSpace(@string))
			{
				LogRefundDebug("Read refund ledger: empty payload.");
				return new List<RefundMaterial>();
			}
			try
			{
				ZPackage val2 = new ZPackage(@string);
				int num = val2.ReadInt();
				if (num != 1)
				{
					LogRefundInfo($"Read refund ledger: unsupported version {num}.");
					return new List<RefundMaterial>();
				}
				int num2 = val2.ReadInt();
				List<RefundMaterial> list = new List<RefundMaterial>(num2);
				for (int i = 0; i < num2; i++)
				{
					list.Add(new RefundMaterial
					{
						ItemName = val2.ReadString(),
						PrefabName = val2.ReadString(),
						Amount = val2.ReadInt()
					});
				}
				LogRefundInfo($"Read refund ledger: {list.Count} material entries, total={list.Sum((RefundMaterial item) => item.Amount)}.");
				return list;
			}
			catch (Exception ex)
			{
				LogRefundInfo("Failed to read refund payload: " + ex.Message);
				return new List<RefundMaterial>();
			}
		}

		private void WriteRefundMaterials(IEnumerable<RefundMaterial> materials)
		{
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Expected O, but got Unknown
			ZNetView? nview = _nview;
			ZDO val = ((nview != null) ? nview.GetZDO() : null);
			if (val == null)
			{
				LogRefundDebug("Write refund ledger skipped: no ZDO.");
				return;
			}
			List<RefundMaterial> list = materials.Where((RefundMaterial item) => item.Amount > 0 && !string.IsNullOrWhiteSpace(item.ItemName)).OrderBy<RefundMaterial, string>((RefundMaterial item) => item.ItemName, StringComparer.Ordinal).ToList();
			if (list.Count == 0)
			{
				val.Set("hs_plan_refund_payload", "");
				LogRefundDebug("Cleared refund ledger payload.");
				return;
			}
			ZPackage val2 = new ZPackage();
			val2.Write(1);
			val2.Write(list.Count);
			foreach (RefundMaterial item in list)
			{
				val2.Write(item.ItemName);
				val2.Write(item.PrefabName);
				val2.Write(item.Amount);
			}
			val.Set("hs_plan_refund_payload", val2.GetBase64());
			LogRefundDebug($"Wrote refund ledger: {list.Count} entries, total={list.Sum((RefundMaterial item) => item.Amount)}.");
		}

		private void ClearRefundMaterials()
		{
			ZNetView? nview = _nview;
			if (nview != null)
			{
				ZDO zDO = nview.GetZDO();
				if (zDO != null)
				{
					zDO.Set("hs_plan_refund_payload", "");
				}
			}
			LogRefundDebug("Refund ledger cleared.");
		}

		private string GetBlueprintName()
		{
			ZNetView? nview = _nview;
			if (((nview != null) ? nview.GetZDO() : null) == null)
			{
				return "";
			}
			return _nview.GetZDO().GetString("hs_blueprint_name", "");
		}

		private bool TryGetAnchorTransform(out Vector3 position, out Quaternion rotation)
		{
			//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_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_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)
			position = default(Vector3);
			rotation = default(Quaternion);
			ZNetView? nview = _nview;
			if (((nview != null) ? nview.GetZDO() : null) == null)
			{
				return false;
			}
			ZDO zDO = _nview.GetZDO();
			position = new Vector3(ReadRequiredFloat(zDO, "hs_anchor_x"), ReadRequiredFloat(zDO, "hs_anchor_y"), ReadRequiredFloat(zDO, "hs_anchor_z"));
			rotation = new Quaternion(ReadRequiredFloat(zDO, "hs_anchor_rot_x"), ReadRequiredFloat(zDO, "hs_anchor_rot_y"), ReadRequiredFloat(zDO, "hs_anchor_rot_z"), ReadRequiredFloat(zDO, "hs_anchor_rot_w"));
			if (IsFinite(position.x) && IsFinite(position.y) && IsFinite(position.z) && IsFinite(rotation.x) && IsFinite(rotation.y) && IsFinite(rotation.z))
			{
				return IsFinite(rotation.w);
			}
			return false;
		}

		private static float ReadRequiredFloat(ZDO zdo, string key)
		{
			return zdo.GetFloat(key, float.NaN);
		}

		private static bool IsFinite(float value)
		{
			if (!float.IsNaN(value))
			{
				return !float.IsInfinity(value);
			}
			return false;
		}

		private void OnDestroyed()
		{
			ReleaseAzuCraftyBoxesContainer("PlanChest.WearNTear.m_onDestroyed");
			TryRefundDepositedMaterials("WearNTear.m_onDestroyed");
		}

		private void ReleaseAzuCraftyBoxesContainer(string source)
		{
			AzuCraftyBoxesCompat.RemoveContainer((Container?)(((Object)(object)_container != (Object)null && Object.op_Implicit((Object)(object)_container)) ? ((object)_container) : ((object)((Component)this).GetComponent<Container>())), source);
		}

		private void TryRefundDepositedMaterials(string source)
		{
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			if (_refundStarted || (Object)(object)_nview == (Object)null)
			{
				LogRefundDebug($"{source}: skipped refund. started={_refundStarted}, nview={(Object)(object)_nview != (Object)null}.");
				return;
			}
			ZDO zDO = _nview.GetZDO();
			if (zDO == null || zDO.GetBool("hs_plan_confirmed", false))
			{
				LogRefundDebug(string.Format("{0}: skipped refund. zdo={1}, confirmed={2}.", source, zDO != null, (zDO != null) ? new bool?(zDO.GetBool("hs_plan_confirmed", false)) : null));
				return;
			}
			if (_nview.IsValid() && !_nview.IsOwner())
			{
				LogRefundDebug($"{source}: skipped refund because this peer is not owner. valid={_nview.IsValid()}.");
				return;
			}
			_refundStarted = true;
			LogRefundInfo(string.Format("{0}: refund starting at {1}. valid={2}, owner={3}, payloadBytes={4}.", source, ((Component)this).transform.position, _nview.IsValid(), _nview.IsOwner(), zDO.GetString("hs_plan_refund_payload", "").Length));
			try
			{
				RefundDepositedMaterials(source);
			}
			catch (Exception arg)
			{
				HomesteadPlugin.HomesteadLogger.LogWarning((object)$"Blueprint refund failed during {source}: {arg}");
			}
		}

		private void RefundDepositedMaterials(string source)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			List<RefundMaterial> list = ReadRefundMaterials();
			if (list.All((RefundMaterial material) => material.Amount <= 0))
			{
				LogRefundInfo("Refund skipped: no deposited materials found.");
				return;
			}
			ClearDepositedMaterials();
			Vector3 position = ((Component)this).transform.position;
			LogRefundInfo($"Queueing refund materials from {source}: entries={list.Count}, total={list.Sum((RefundMaterial material) => material.Amount)}.");
			ScheduleRefundDrop(list, position, source);
		}

		private static void ScheduleRefundDrop(List<RefundMaterial> refundMaterials, Vector3 dropPosition, string source)
		{
			//IL_0022: 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)
			if ((Object)(object)HomesteadPlugin.Instance != (Object)null)
			{
				((MonoBehaviour)HomesteadPlugin.Instance).StartCoroutine(DropRefundMaterialsDeferred(refundMaterials, dropPosition, source));
			}
			else
			{
				DropRefundMaterials(refundMaterials, dropPosition, source);
			}
		}

		[IteratorStateMachine(typeof(<DropRefundMaterialsDeferred>d__103))]
		private static IEnumerator DropRefundMaterialsDeferred(List<RefundMaterial> refundMaterials, Vector3 dropPosition, string source)
		{
			//IL_000e: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DropRefundMaterialsDeferred>d__103(0)
			{
				refundMaterials = refundMaterials,
				dropPosition = dropPosition,
				source = source
			};
		}

		private static void DropRefundMaterials(IEnumerable<RefundMaterial> refundMaterials, Vector3 dropPosition, string source)
		{
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			LogRefundInfo("Dropping queued refund materials from " + source + ".");
			foreach (RefundMaterial refundMaterial in refundMaterials)
			{
				if (refundMaterial.Amount > 0)
				{
					GameObject val = FindPrefab(refundMaterial.PrefabName);
					ItemDrop val2 = (((Object)(object)val != (Object)null) ? val.GetComponent<ItemDrop>() : null);
					if ((Object)(object)val2 == (Object)null)
					{
						HomesteadPlugin.HomesteadLogger.LogWarning((object)("Failed to refund Homestead blueprint material '" + refundMaterial.ItemName + "': prefab '" + refundMaterial.PrefabName + "' was not found."));
					}
					else
					{
						LogRefundInfo($"Dropping refund material '{refundMaterial.ItemName}' prefab={refundMaterial.PrefabName} amount={refundMaterial.Amount}.");
						GiveOrDropItem(val2.m_itemData, refundMaterial.Amount, dropPosition, preferInventory: false, val);
					}
				}
			}
		}

		private static void LogRefundInfo(string message)
		{
		}

		private static void LogRefundDebug(string message)
		{
		}

		public void DrawRequirementOverlay(InventoryGrid grid)
		{
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)grid == (Object)null || !ReloadPlan())
			{
				return;
			}
			List<ZoneBlueprintRequirement> missingRequirementList = GetMissingRequirementList();
			int num = 0;
			foreach (Element element in grid.m_elements)
			{
				if (num >= missingRequirementList.Count)
				{
					break;
				}
				if (!element.m_used)
				{
					ZoneBlueprintRequirement zoneBlueprintRequirement = missingRequirementList[num++];
					Sprite requirementIcon = GetRequirementIcon(zoneBlueprintRequirement);
					element.m_used = true;
					((Behaviour)element.m_icon).enabled = (Object)(object)requirementIcon != (Object)null;
					element.m_icon.sprite = requirementIcon;
					((Graphic)element.m_icon).color = new Color(1f, 1f, 1f, 0.45f);
					((Behaviour)element.m_amount).enabled = true;
					element.m_amount.text = zoneBlueprintRequirement.Amount.ToString();
					((Behaviour)element.m_quality).enabled = false;
					((Behaviour)element.m_equiped).enabled = false;
					((Behaviour)element.m_queued).enabled = false;
					((Behaviour)element.m_noteleport).enabled = false;
					((Behaviour)element.m_food).enabled = false;
					((Component)element.m_durability).gameObject.SetActive(false);
					element.m_tooltip.m_topic = Localization.instance.Localize(zoneBlueprintRequirement.DisplayName);
					element.m_tooltip.m_text = HomesteadLocalization.Format("hs_blueprint_requirement_tooltip", zoneBlueprintRequirement.Amount);
				}
			}
		}

		private static Sprite? GetRequirementIcon(ZoneBlueprintRequirement requirement)
		{
			GameObject val = FindPrefab(requirement.PrefabName);
			ItemDrop val2 = (((Object)(object)val != (Object)null) ? val.GetComponent<ItemDrop>() : null);
			if (!((Object)(object)val2 != (Object)null))
			{
				return null;
			}
			return val2.m_itemData.GetIcon();
		}

		public static bool TryGetAnchor(Container? container, out ZoneBlueprintPlanAnchor anchor)
		{
			anchor = null;
			if (!Object.op_Implicit((Object)(object)container))
			{
				return false;
			}
			anchor = ((Component)container).GetComponent<ZoneBlueprintPlanAnchor>();
			if ((Object)(object)anchor != (Object)null)
			{
				return anchor.ReloadPlan();
			}
			return false;
		}

		private static void Message(Player player, string message, MessageType type)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			HomesteadPlugin.HomesteadLogger.LogInfo((object)message);
			((Character)player).Message(type, message, 0, (Sprite)null);
		}

		private static string FormatShortcut(KeyboardShortcut shortcut)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			string text = ConfigValueHelpers.FormatShortcut(shortcut);
			if (!string.Equals(text, "None", StringComparison.OrdinalIgnoreCase))
			{
				return text;
			}
			return "Unbound";
		}
	}
	internal static class ZoneBlueprintPlanChestPrefab
	{
		internal const string PrefabName = "piece_chest_wood_blueprint";

		private const string BasePrefabName = "piece_chest_wood";

		internal static readonly int PrefabHash = StringExtensionMethods.GetStableHashCode("piece_chest_wood_blueprint");

		private static ManualLogSource? _logger;

		private static bool _initialized;

		private static bool _registered;

		public static void Initialize(ManualLogSource logger)
		{
			_logger = logger;
			if (!_initialized)
			{
				_initialized = true;
				PrefabManager.OnVanillaPrefabsAvailable += RegisterPrefab;
				RegisterPrefab();
			}
		}

		public static HomesteadCommandResult PlacePlanChest(string blueprintName, Player player, Vector3 anchor, Quaternion anchorRotation, Vector3 chestPosition, Quaternion chestRotation)
		{
			//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)
			//IL_0011: 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)
			long playerID = player.GetPlayerID();
			return PlacePlanChest(blueprintName, playerID, HomesteadPlayerIdentity.ResolveLocalPlatformId(playerID), anchor, anchorRotation, chestPosition, chestRotation, 0L);
		}

		public static HomesteadCommandResult PlacePlanChest(string blueprintName, long playerId, string ownerPlatformId, Vector3 anchor, Quaternion anchorRotation, Vector3 chestPosition, Quaternion chestRotation, long vfxExcludePeer = 0L)
		{
			//IL_0038: 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_0092: 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_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			RegisterPrefab();
			if (!ZoneBlueprintChestLifecycle.CanPlaceChests(ownerPlatformId, 1, out string reason))
			{
				return HomesteadCommandResult.Fail(reason);
			}
			GameObject prefab = GetPrefab();
			if (!Object.op_Implicit((Object)(object)prefab))
			{
				return HomesteadCommandResult.Fail(HomesteadLocalization.Text("hs_blueprint_chest_prefab_not_ready"));
			}
			GameObject val = null;
			try
			{
				val = Object.Instantiate<GameObject>(prefab, chestPosition, chestRotation);
				Piece component = val.GetComponent<Piece>();
				if ((Object)(object)component != (Object)null)
				{
					component.SetCreator(playerId);
				}
				ZNetView component2 = val.GetComponent<ZNetView>();
				if ((Object)(object)component2 != (Object)null && component2.IsValid())
				{
					ZoneBlueprintChestLifecycle.SetOwnerPlatformId(component2.GetZDO(), ownerPlatformId);
				}
				(val.GetComponent<ZoneBlueprintPlanAnchor>() ?? val.AddComponent<ZoneBlueprintPlanAnchor>()).SetPlan(blueprintName, anchor, anchorRotation);
				ZoneChestPlacement.PlayPlaceEffect(val);
				ZoneChestPlacement.SafeOnPlaced(val, _logger, "Blueprint chest");
				ZoneBlueprintChestVfx.BroadcastPlace("plan", ToTransformPayload(chestPosition, chestRotation), vfxExcludePeer);
				ZoneLimitCompat.RebuildCounts();
				return HomesteadCommandResult.Ok(HomesteadLocalization.Format("hs_blueprint_chest_placed", blueprintName));
			}
			catch (Exception ex)
			{
				ZoneChestPlacement.DestroySpawned(val);
				return HomesteadCommandResult.Fail(HomesteadLocalization.Format("hs_blueprint_chest_place_failed", ex.Message));
			}
		}

		public static GameObject? CreatePreview()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			RegisterPrefab();
			GameObject prefab = GetPrefab();
			if (!Object.op_Implicit((Object)(object)prefab))
			{
				return null;
			}
			GameObject val = new GameObject("HomesteadBlueprintChestPreview");
			if (ZoneBlueprintVisuals.CopyVisuals(prefab.transform, val.transform) == 0)
			{
				Object.Destroy((Object)(object)val);
				return null;
			}
			return val;
		}

		private static GameObject? GetPrefab()
		{
			GameObject prefab = PrefabManager.Instance.GetPrefab("piece_chest_wood_blueprint");
			if (prefab == null)
			{
				ZNetScene instance = ZNetScene.instance;
				if (instance == null)
				{
					return null;
				}
				prefab = instance.GetPrefab("piece_chest_wood_blueprint");
			}
			return prefab;
		}

		internal static Sprite? GetIcon()
		{
			RegisterPrefab();
			GameObject? prefab = GetPrefab();
			if (prefab == null)
			{
				return null;
			}
			return prefab.GetComponent<Piece>()?.m_icon;
		}

		public static bool PlayPlaceEffect(Vector3 position, Quaternion rotation)
		{
			//IL_000a: 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)
			RegisterPrefab();
			return ZoneChestPlacement.PlayPlaceEffect(GetPrefab(), position, rotation);
		}

		private static ZoneBlueprintStoreTransformPayload ToTransformPayload(Vector3 position, Quaternion rotation)
		{
			//IL_000f: 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_0021: 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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: 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)
			ZoneBlueprintStoreTransformPayload zoneBlueprintStoreTransformPayload = new ZoneBlueprintStoreTransformPayload();
			zoneBlueprintStoreTransformPayload.Pos = new float[3] { position.x, position.y, position.z };
			zoneBlueprintStoreTransformPayload.Rot = new float[4] { rotation.x, rotation.y, rotation.z, rotation.w };
			return zoneBlueprintStoreTransformPayload;
		}

		private static void RegisterPrefab()
		{
			if (_registered)
			{
				return;
			}
			if (Object.op_Implicit((Object)(object)PrefabManager.Instance.GetPrefab("piece_chest_wood_blueprint")))
			{
				_registered = true;
				return;
			}
			if (!Object.op_Implicit((Object)(object)PrefabManager.Instance.GetPrefab("piece_chest_wood")))
			{
				ZNetScene instance = ZNetScene.instance;
				if (!Object.op_Implicit((Object)(object)((instance != null) ? instance.GetPrefab("piece_chest_wood") : null)))
				{
					return;
				}
			}
			GameObject val = PrefabManager.Instance.CreateClonedPrefab("piece_chest_wood_blueprint", "piece_chest_wood");
			if (Object.op_Implicit((Object)(object)val))
			{
				ConfigurePrefab(val);
				PrefabManager.Instance.AddPrefab(val);
				PrefabManager.Instance.RegisterToZNetScene(val);
				_registered = true;
				ManualLogSource? logger = _logger;
				if (logger != null)
				{
					logger.LogInfo((object)"Registered Homestead blueprint chest prefab.");
				}
			}
		}

		private static void ConfigurePrefab(GameObject prefab)
		{
			//IL_003b: 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: Expected O, but got Unknown
			Container component = prefab.GetComponent<Container>();
			if ((Object)(object)component != (Object)null)
			{
				component.m_name = HomesteadLocalization.Token("hs_blueprint_chest_name");
				component.m_width = 8;
				component.m_height = BlueprintConfig.ChestRows;
				component.m_autoDestroyEmpty = false;
				component.m_privacy = (PrivacySetting)2;
				component.m_defaultItems = new DropTable();
			}
			Piece component2 = prefab.GetComponent<Piece>();
			if ((Object)(object)component2 != (Object)null)
			{
				component2.m_name = HomesteadLocalization.Token("hs_blueprint_chest_name");
				component2.m_description = HomesteadLocalization.Token("hs_blueprint_chest_desc");
				component2.m_resources = Array.Empty<Requirement>();
			}
			if ((Object)(object)prefab.GetComponent<ZoneBlueprintPlanAnchor>() == (Object)null)
			{
				prefab.AddComponent<ZoneBlueprintPlanAnchor>();
			}
		}
	}
	internal static class ZoneBlueprintPreviewBuilder
	{
		private readonly struct VisualDescriptor
		{
			public string Name { get; }

			public Mesh Mesh { get; }

			public Material[] Materials { get; }

			public bool Skinned { get; }

			public Vector3 LocalPosition { get; }

			public Quaternion LocalRotation { get; }

			public Vector3 LocalScale { get; }

			public VisualDescriptor(string name, Mesh mesh, Material[] materials, bool skinned, Vector3 localPosition, Quaternion localRotation, Vector3 localScale)
			{
				//IL_001e: 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_0026: 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_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				Name = name;
				Mesh = mesh;
				Materials = materials;
				Skinned = skinned;
				LocalPosition = localPosition;
				LocalRotation = localRotation;
				LocalScale = localScale;
			}
		}

		private static readonly Dictionary<string, List<VisualDescriptor>> VisualCache = new Dictionary<string, List<VisualDescriptor>>(StringComparer.OrdinalIgnoreCase);

		public static GameObject? CreateVisualPreview(GameObject prefab, Vector3 localPosition, Quaternion localRotation, Vector3 scale, int index, Transform parent)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			//IL_0098: 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)
			List<VisualDescriptor> visuals = GetVisuals(prefab);
			if (visuals.Count == 0)
			{
				return null;
			}
			GameObject val = new GameObject($"HomesteadBlueprintPreview_{index:D3}");
			val.transform.SetParent(parent, false);
			val.transform.localPosition = localPosition;
			val.transform.localRotation = localRotation;
			val.transform.localScale = scale;
			foreach (VisualDescriptor item in visuals)
			{
				GameObject val2 = new GameObject(item.Name);
				val2.transform.SetParent(val.transform, false);
				val2.transform.localPosition = item.LocalPosition;
				val2.transform.localRotation = item.LocalRotation;
				val2.transform.localScale = item.LocalScale;
				if (item.Skinned)
				{
					SkinnedMeshRenderer obj = val2.AddComponent<SkinnedMeshRenderer>();
					obj.sharedMesh = item.Mesh;
					((Renderer)obj).sharedMaterials = item.Materials;
					((Renderer)obj).shadowCastingMode = (ShadowCastingMode)0;
					((Renderer)obj).receiveShadows = false;
				}
				else
				{
					MeshFilter val3 = val2.AddComponent<MeshFilter>();
					MeshRenderer obj2 = val2.AddComponent<MeshRenderer>();
					val3.sharedMesh = item.Mesh;
					((Renderer)obj2).sharedMaterials = item.Materials;
					((Renderer)obj2).shadowCastingMode = (ShadowCastingMode)0;
					((Renderer)obj2).receiveShadows = false;
				}
			}
			return val;
		}

		public static void ClearCache()
		{
			VisualCache.Clear();
		}

		private static List<VisualDescriptor> GetVisuals(GameObject prefab)
		{
			string prefabName = Utils.GetPrefabName(prefab);
			if (VisualCache.TryGetValue(prefabName, out List<VisualDescriptor> value))
			{
				return value;
			}
			List<VisualDescriptor> list = new List<VisualDescriptor>();
			CollectVisuals(prefab.transform, prefab.transform, list);
			VisualCache[prefabName] = list;
			return list;
		}

		private static void CollectVisuals(Transform root, Transform source, List<VisualDescriptor> visuals)
		{
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Expected O, but got Unknown
			if (!((Component)source).gameObject.activeSelf)
			{
				return;
			}
			MeshFilter component = ((Component)source).GetComponent<MeshFilter>();
			MeshRenderer component2 = ((Component)source).GetComponent<MeshRenderer>();
			if ((Object)(object)component != (Object)null && (Object)(object)component.sharedMesh != (Object)null && (Object)(object)component2 != (Object)null && ((Renderer)component2).enabled)
			{
				visuals.Add(CreateDescriptor(root, source, component.sharedMesh, ((Renderer)component2).sharedMaterials, skinned: false));
			}
			SkinnedMeshRenderer component3 = ((Component)source).GetComponent<SkinnedMeshRenderer>();
			if ((Object)(object)component3 != (Object)null && (Object)(object)component3.sharedMesh != (Object)null && ((Renderer)component3).enabled)
			{
				visuals.Add(CreateDescriptor(root, source, component3.sharedMesh, ((Renderer)component3).sharedMaterials, skinned: true));
			}
			foreach (Transform item in source)
			{
				Transform source2 = item;
				CollectVisuals(root, source2, visuals);
			}
		}

		private static VisualDescriptor CreateDescriptor(Transform root, Transform source, Mesh mesh, Material[] materials, bool skinned)
		{
			//IL_0001: 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_000c: 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_0028: Unknown result type (might be due to invalid IL or missing references)
			Decompose(root.worldToLocalMatrix * source.localToWorldMatrix, out var position, out var rotation, out var scale);
			return new VisualDescriptor(((Object)source).name, mesh, materials, skinned, position, rotation, scale);
		}

		private static void Decompose(Matrix4x4 matrix, out Vector3 position, out Quaternion rotation, out Vector3 scale)
		{
			//IL_0003: 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_000d: 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_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_001f: 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_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_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: 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_0083: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = Vector4.op_Implicit(((Matrix4x4)(ref matrix)).GetColumn(0));
			Vector3 val2 = Vector4.op_Implicit(((Matrix4x4)(ref matrix)).GetColumn(1));
			Vector3 val3 = Vector4.op_Implicit(((Matrix4x4)(ref matrix)).GetColumn(2));
			position = Vector4.op_Implicit(((Matrix4x4)(ref matrix)).GetColumn(3));
			scale = new Vector3(((Vector3)(ref val)).magnitude, ((Vector3)(ref val2)).magnitude, ((Vector3)(ref val3)).magnitude);
			rotation = ((((Vector3)(ref val3)).sqrMagnitude > 1E-06f && ((Vector3)(ref val2)).sqrMagnitude > 1E-06f) ? Quaternion.LookRotation(val3, val2) : Quaternion.identity);
		}
	}
	internal sealed class ZoneBlueprintSaveTool : MonoBehaviour
	{
		private sealed class SaveSelection
		{
			public Vector3 Anchor { get; }

			public Quaternion AnchorRotation { get; }

			public float Radius { get; }

			public List<ZDOID> Zdos { get; }

			public SaveSelection(Vector3 anchor, Quaternion anchorRotation, float radius, List<ZDOID> zdos)
			{
				//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_000e: 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)
				Anchor = anchor;
				AnchorRotation = anchorRotation;
				Radius = radius;
				Zdos = zdos;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass73_0
		{
			public Sprite icon;

			public bool renderFinished;

			internal void <RenderQueuedIcons>b__0(Sprite? renderedIcon)
			{
				icon = renderedIcon;
				renderFinished = true;
			}
		}

		[CompilerGenerated]
		private sealed class <BuildSelectionPreview>d__59 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public SaveSelection selection;

			public IReadOnlyList<ZDO> zdos;

			public ZoneBlueprintSaveTool <>4__this;

			public GameObject root;

			private Quaternion <inverseAnchorRotation>5__2;

			private int <count>5__3;

			private IEnumerator<ZDO> <>7__wrap3;

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

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

			[DebuggerHidden]
			public <BuildSelectionPreview>d__59(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//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_0037: 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_00c0: 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_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d4: 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_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_00e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: 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_00fb: 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_00ff: Unknown result type (might be due to invalid IL or missing references)
				bool result;
				try
				{
					int num = <>1__state;
					ZoneBlueprintSaveTool zoneBlueprintSaveTool = <>4__this;
					switch (num)
					{
					default:
						result = false;
						goto end_IL_0000;
					case 0:
						<>1__state = -1;
						<inverseAnchorRotation>5__2 = Quaternion.Inverse(selection.AnchorRotation);
						<count>5__3 = 0;
						<>7__wrap3 = zdos.GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						break;
					}
					while (true)
					{
						if (<>7__wrap3.MoveNext())
						{
							ZDO current = <>7__wrap3.Current;
							if (zoneBlueprintSaveTool._selection != selection || (Object)(object)zoneBlueprintSaveTool._selectionPreviewRoot != (Object)(object)root)
							{
								zoneBlueprintSaveTool._previewBuildCoroutine = null;
								result = false;
								<>m__Finally1();
								break;
							}
							if (ZoneBlueprintCommands.TryReadSavableWearNTear(current, out GameObject prefab))
							{
								Vector3 vec = current.GetVec3(ZDOVars.s_scaleHash, prefab.transform.localScale);
								Vector3 localPosition = <inverseAnchorRotation>5__2 * (current.GetPosition() - selection.Anchor);
								Quaternion localRotation = <inverseAnchorRotation>5__2 * current.GetRotation();
								GameObject val = zoneBlueprintSaveTool.CreateVisualPreview(prefab, localPosition, localRotation, vec, <count>5__3, zoneBlueprintSaveTool._selectionPreviewRoot.transform);
								if ((Object)(object)val != (Object)null)
								{
									zoneBlueprintSaveTool._previewVisuals.Add(val);
								}
								<count>5__3++;
								if (<count>5__3 % 64 == 0)
								{
									<>2__current = null;
									<>1__state = 1;
									result = true;
									break;
								}
							}
							continue;
						}
						<>m__Finally1();
						<>7__wrap3 = null;
						zoneBlueprintSaveTool._previewBuildCoroutine = null;
						result = false;
						break;
					}
					end_IL_0000:;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
				return result;
			}

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

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

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

		[CompilerGenerated]
		private sealed class <RenderQueuedIcons>d__73 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public ZoneBlueprintSaveTool <>4__this;

			private <>c__DisplayClass73_0 <>8__1;

			private Stopwatch <renderTimer>5__2;

			private string <blueprintName>5__3;

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

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

			[DebuggerHidden]
			public <RenderQueuedIcons>d__73(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<renderTimer>5__2 = null;
				<blueprintName>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: Expected O, but got Unknown
				//IL_0205: Unknown result type (might be due to invalid IL or missing references)
				//IL_020f: Expected O, but got Unknown
				int num = <>1__state;
				ZoneBlueprintSaveTool zoneBlueprintSaveTool = <>4__this;
				ManualLogSource? logger2;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					goto IL_0234;
				case 1:
					<>1__state = -1;
					goto IL_0234;
				case 2:
					<>1__state = -1;
					goto IL_0234;
				case 3:
					<>1__state = -1;
					goto IL_0188;
				case 4:
					{
						<>1__state = -1;
						<>8__1 = null;
						<renderTimer>5__2 = null;
						<blueprintName>5__3 = null;
						goto IL_0234;
					}
					IL_0234:
					if (zoneBlueprintSaveTool._iconRenderQueue.Count > 0)
					{
						<>8__1 = new <>c__DisplayClass73_0();
						if (ShouldDelayIconRenderForPlacement())
						{
							<>2__current = (object)new WaitForSecondsRealtime(1f);
							<>1__state = 1;
							return true;
						}
						<renderTimer>5__2 = Stopwatch.StartNew();
						<blueprintName>5__3 = zoneBlueprintSaveTool._iconRenderQueue.Dequeue();
						zoneBlueprintSaveTool._queuedIconRenders.Remove(<blueprintName>5__3);
						if (!zoneBlueprintSaveTool._queuedIconBlueprints.TryGetValue(<blueprintName>5__3, out ZoneBlueprintFile value) && !ZoneBlueprintCommands.TryLoadBlueprint(<blueprintName>5__3, out value))
						{
							zoneBlueprintSaveTool._queuedIconBlueprints.Remove(<blueprintName>5__3);
							<>2__current = null;
							<>1__state = 2;
							return true;
						}
						zoneBlueprintSaveTool._queuedIconBlueprints.Remove(<blueprintName>5__3);
						<>8__1.icon = null;
						<>8__1.renderFinished = false;
						try
						{
							ZoneBlueprintVisuals.EnqueueRenderAndCacheIcon(<blueprintName>5__3, value, delegate(Sprite? renderedIcon)
							{
								<>8__1.icon = renderedIcon;
								<>8__1.renderFinished = true;
							});
						}
						catch (Exception ex)
						{
							ManualLogSource? logger = _logger;
							if (logger != null)
							{
								logger.LogWarning((object)("Failed to render Homestead blueprint icon '" + <blueprintName>5__3 + "': " + ex.Message));
							}
							<>8__1.renderFinished = true;
						}
						goto IL_0188;
					}
					zoneBlueprintSaveTool._iconRenderCoroutine = null;
					return false;
					IL_0188:
					if (!<>8__1.renderFinished)
					{
						<>2__current = null;
						<>1__state = 3;
						return true;
					}
					ZoneBlueprintSaveToolMenu.ApplyBlueprintIcon(<blueprintName>5__3, <>8__1.icon);
					<renderTimer>5__2.Stop();
					logger2 = _logger;
					if (logger2 != null)
					{
						logger2.LogDebug((object)$"Homestead blueprint icon render completed for '{<blueprintName>5__3}' in {<renderTimer>5__2.Elapsed.TotalMilliseconds:0.0} ms; queued={zoneBlueprintSaveTool._iconRenderQueue.Count}.");
					}
					<>2__current = (object)new WaitForSecondsRealtime(1.25f);
					<>1__state = 4;
					return true;
				}
			}

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

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

		private const float MinSideLength = 2f;

		private const float SizeStep = 2f;

		private const float PreviewLift = 4f;

		private const int PreviewBuildBatchSize = 64;

		private const int SaveNameMaxLength = 64;

		private const float TargetOverlayRefreshInterval = 0.3f;

		private const float IconRenderIntervalSeconds = 1.25f;

		private const float IconRenderPlacementDelaySeconds = 1f;

		private static ManualLogSource? _logger;

		private static ZoneBlueprintSaveTool? _instance;

		private static float? _lastAreaYaw;

		private readonly List<GameObject> _previewVisuals = new List<GameObject>();

		private readonly List<ZDO> _nearbyTargetZdos = new List<ZDO>();

		private readonly List<ZDO> _targetCandidateZdos = new List<ZDO>();

		private readonly Queue<string> _iconRenderQueue = new Queue<string>();

		private readonly HashSet<string> _queuedIconRenders = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private readonly Dictionary<string, ZoneBlueprintFile> _queuedIconBlueprints = new Dictionary<string, ZoneBlueprintFile>(StringComparer.OrdinalIgnoreCase);

		private ZoneAreaToolController? _areaTool;

		private GameObject? _selectionPreviewRoot;

		private SaveSelection? _selection;

		private Coroutine? _iconRenderCoroutine;

		private Coroutine? _previewBuildCoroutine;

		private bool _active;

		private GameObject? _savePanel;

		private InputField? _saveNameInput;

		private Text? _saveCountText;

		private Text? _saveStatusText;

		private string _saveName = "";

		private string _saveStatus = "";

		private bool _focusSaveName;

		private bool _saveInputBlocked;

		private float _selectionPreviewYawOffset;

		public static bool HasSelection => _instance?._selection != null;

		public static bool IsActive
		{
			get
			{
				ZoneBlueprintSaveTool? instance = _instance;
				if (instance == null)
				{
					return false;
				}
				return (instance._areaTool?.Active).GetValueOrDefault();
			}
		}

		private static float MaxSelectableSide => Mathf.Max(2f, AreaToolConfig.BlueprintSaveMaxSide);

		private ZoneAreaToolController AreaTool => _areaTool ?? (_areaTool = new ZoneAreaToolController((MonoBehaviour)(object)this, new ZoneAreaToolController.Options
		{
			MinSide = 2f,
			SizeStep = 2f,
			MaxSide = () => MaxSelectableSide,
			DefaultWidth = () => AreaToolConfig.BlueprintSaveDefaultWidth,
			DefaultDepth = () => AreaToolConfig.BlueprintSaveDefaultDepth,
			Color = () => AreaToolConfig.BlueprintSaveColor,
			RangeLineName = "HomesteadBlueprintRadius",
			TargetOverlayName = "HomesteadAreaSaveTarget",
			TargetOverlayRefreshInterval = 0.3f,
			GetSavedYaw = () => _lastAreaYaw,
			SetSavedYaw = delegate(float yaw)
			{
				_lastAreaYaw = yaw;
			},
			IsLocked = () => _selection != null,
			GetEffectiveYaw = (float yaw) => (_selection != null) ? ZoneAreaSelection.NormalizeYaw(yaw + _selectionPreviewYawOffset) : yaw,
			OnLockedScroll = delegate(float scroll)
			{
				float num = ((scroll > 0f) ? PlacementControlConfig.RotationStep : (0f - PlacementControlConfig.RotationStep));
				_selectionPreviewYawOffset = ZoneAreaSelection.NormalizeYaw(_selectionPreviewYawOffset + num);
			},
			OnFrame = delegate
			{
				UpdateSelectionPreview();
				UpdateSavePanel();
			},
			ShouldBlockToolInput = () => _selection != null && IsSaveNameInputFocused(),
			StatusTitle = () => (_selection != null) ? HomesteadLocalization.Text("hs_area_save_preview_name") : HomesteadLocalization.Text("hs_area_save_name"),
			FindCandidates = FindSaveBoundaryPreviewCandidates,
			OnClick = PickSelection
		}));

		public static void Initialize(ManualLogSource logger)
		{
			_logger = logger;
			ZoneBlueprintSaveToolMenu.Initialize();
			EnsureInstance();
		}

		public static void Activate(Player player)
		{
			EnsureInstance();
			_instance?.ActivateInternal(player);
		}

		public static void Deactivate()
		{
			_instance?.DeactivateInternal();
		}

		public static void ClearSelection()
		{
			_instance?.ClearSelectionInternal();
		}

		public static void QueueMenuRefresh(string blueprintName)
		{
			EnsureInstance();
			ZoneBlueprintSaveToolMenu.RequestHammerTableRefresh(blueprintName);
		}

		public static void QueueIconRender(string blueprintName, ZoneBlueprintFile? blueprint = null)
		{
			EnsureInstance();
			_instance?.QueueIconRenderInternal(blueprintName, blueprint);
		}

		public static bool TryGetSelectedBlueprint(string name, Player player, out ZoneBlueprintFile blueprint, out string reason)
		{
			//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_0092: 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_00e8: Unknown result type (might be due to invalid IL or missing references)
			blueprint = null;
			reason = "";
			if (_instance?._selection == null)
			{
				reason = HomesteadLocalization.Format("hs_blueprint_no_preview_selected", "Wheel", ZoneAreaToolShared.FormatScaleInput(), ZoneAreaToolShared.FormatDepthInput(), ZoneAreaToolShared.FormatWidthInput());
				return false;
			}
			if (ZDOMan.instance == null)
			{
				reason = HomesteadLocalization.Text("hs_common_world_not_ready");
				return false;
			}
			SaveSelection selection = _instance._selection;
			List<ZDO> list = new List<ZDO>();
			foreach (ZDOID zdo in selection.Zdos)
			{
				ZDO zDO = ZDOMan.instance.GetZDO(zdo);
				if (zDO != null && zDO.IsValid())
				{
					list.Add(zDO);
				}
			}
			if (list.Count == 0)
			{
				reason = HomesteadLocalization.Text("hs_blueprint_preview_invalid");
				return false;
			}
			blueprint = ZoneBlueprintCommands.CaptureBlueprintFromZdos(name, player, selection.Anchor, selection.AnchorRotation, list, selection.Radius);
			return true;
		}

		private static void EnsureInstance()
		{
			//IL_001f: 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_002a: Expected O, but got Unknown
			if (!((Object)(object)_instance != (Object)null) || !Object.op_Implicit((Object)(object)_instance))
			{
				GameObject val = new GameObject("HomesteadBlueprintSaveTool");
				Object.DontDestroyOnLoad((Object)val);
				_instance = val.AddComponent<ZoneBlueprintSaveTool>();
			}
		}

		private void ActivateInternal(Player player)
		{
			_active = true;
			AreaTool.Activate(player);
		}

		private void DeactivateInternal()
		{
			_active = false;
			_areaTool?.Deactivate();
			_saveStatus = "";
			_focusSaveName = false;
			_selectionPreviewYawOffset = 0f;
			SetSaveUiInputBlocked(blocked: false);
			SetSavePanelVisible(visible: false);
			_selection = null;
			ClearPreviewLines();
		}

		private void ClearSelectionInternal()
		{
			_selection = null;
			_saveStatus = "";
			_focusSaveName = false;
			_selectionPreviewYawOffset = 0f;
			_areaTool?.ResetOffsets();
			SetSaveUiInputBlocked(blocked: false);
			SetSavePanelVisible(visible: false);
			ClearPreviewLines();
			ZoneAreaToolStatusHud.Hide();
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer != null)
			{
				((Character)localPlayer).Message((MessageType)1, HomesteadLocalization.Text("hs_blueprint_preview_cleared"), 0, (Sprite)null);
			}
		}

		private void Update()
		{
			if (!_active)
			{
				ZoneAreaToolController? areaTool = _areaTool;
				if (areaTool == null || !areaTool.Active)
				{
					return;
				}
			}
			if (!AreaTool.Tick())
			{
				DeactivateInternal();
			}
		}

		private void OnDestroy()
		{
			SetSaveUiInputBlocked(blocked: false);
			DestroySavePanel();
			_areaTool?.Destroy();
			_areaTool = null;
			ClearPreviewLines();
			if ((Object)(object)_instance == (Object)(object)this)
			{
				_instance = null;
			}
		}

		private void PickSelection(Player player)
		{
			PickSelection(player, AreaTool.CurrentArea);
		}

		private void PickSelection(Player player, ZoneAreaSelection area)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: 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)
			if (!AreaTool.HasAimPoint)
			{
				return;
			}
			BlueprintAreaSaveCreatorMode areaSaveCreatorMode = BlueprintConfig.AreaSaveCreatorMode;
			List<ZDO> list = ZoneBlueprintCommands.FindBlueprintWearNTearZdos(player, area, areaSaveCreatorMode);
			if (list.Count == 0)
			{
				_selection = null;
				ClearPreviewLines();
				Message(player, HomesteadLocalization.Format("hs_blueprint_no_targets_in_area", BlueprintConfig.AreaSaveEligibleTargetLabel, AreaTool.FormattedSize));
				return;
			}
			Quaternion rotation = area.Rotation;
			_selection = new SaveSelection(area.Center, rotation, area.HalfDiagonal, list.Select((ZDO zdo) => zdo.m_uid).ToList());
			_selectionPreviewYawOffset = 0f;
			_saveName = GenerateDefaultBlueprintName();
			_saveStatus = "";
			_focusSaveName = false;
			EnsureSavePanel();
			RefreshSavePanel();
			SetSavePanelVisible(visible: true);
			ReleaseSaveNameFocus();
			DrawSelectionPreview(list);
		}

		private void SaveSelectionFromUi()
		{
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null))
			{
				HomesteadCommandResult homesteadCommandResult = ZoneBlueprintCommands.SaveSelectedBlueprint(_saveName, localPlayer);
				_saveStatus = (homesteadCommandResult.Success ? "Saved." : homesteadCommandResult.Message);
				Message(localPlayer, homesteadCommandResult.Message, (MessageType)(homesteadCommandResult.Success ? 1 : 2));
				if (homesteadCommandResult.Success)
				{
					_selection = null;
					_selectionPreviewYawOffset = 0f;
					_focusSaveName = false;
					SetSaveUiInputBlocked(blocked: false);
					SetSavePanelVisible(visible: false);
					ClearPreviewLines();
				}
			}
		}

		private IReadOnlyList<ZDO> FindSaveBoundaryPreviewCandidates(Player player, ZoneAreaSelection area)
		{
			_targetCandidateZdos.Clear();
			if (ZDOMan.instance == null || (Object)(object)ZNetScene.instance == (Object)null || (Object)(object)player == (Object)null)
			{
				return _targetCandidateZdos;
			}
			long playerID = player.GetPlayerID();
			if (playerID == 0L)
			{
				return _targetCandidateZdos;
			}
			ZoneAreaTargetOverlay.CollectNearbyZdos(area, _nearbyTargetZdos);
			foreach (ZDO nearbyTargetZdo in _nearbyTargetZdos)
			{
				if (!ZoneBlueprintCommands.IsHomesteadBlueprintChest(nearbyTargetZdo) && ZoneBlueprintCommands.TryReadSavableWearNTear(nearbyTargetZdo, out GameObject _) && IsLoadedWearNTear(nearbyTargetZdo))
				{
					long @long = nearbyTargetZdo.GetLong(ZDOVars.s_creator, 0L);
					if (BlueprintConfig.AreaSaveAllowsCreator(playerID, @long))
					{
						_targetCandidateZdos.Add(nearbyTargetZdo);
					}
				}
			}
			return _targetCandidateZdos;
		}

		private static bool IsLoadedWearNTear(ZDO zdo)
		{
			if ((Object)(object)ZNetScene.instance == (Object)null)
			{
				return false;
			}
			ZNetView val = ZNetScene.instance.FindInstance(zdo);
			if ((Object)(object)val != (Object)null)
			{
				return (Object)(object)((Component)val).GetComponent<WearNTear>() != (Object)null;
			}
			return false;
		}

		private void DrawSelectionPreview(IReadOnlyList<ZDO> zdos)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0047: 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_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_0076: Unknown result type (might be due to invalid IL or missing references)
			ClearPreviewLines();
			if (_selection != null)
			{
				_selectionPreviewRoot = new GameObject("HomesteadBlueprintHeldPreview");
				_selectionPreviewRoot.transform.SetParent(((Component)this).transform, false);
				_selectionPreviewRoot.transform.position = AreaTool.AimPoint + Vector3.up * 4f;
				_selectionPreviewRoot.transform.rotation = _selection.AnchorRotation;
				_previewBuildCoroutine = ((MonoBehaviour)this).StartCoroutine(BuildSelectionPreview(zdos.ToList(), _selection, _selectionPreviewRoot));
			}
		}

		[IteratorStateMachine(typeof(<BuildSelectionPreview>d__59))]
		private IEnumerator BuildSelectionPreview(IReadOnlyList<ZDO> zdos, SaveSelection selection, GameObject root)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <BuildSelectionPreview>d__59(0)
			{
				<>4__this = this,
				zdos = zdos,
				selection = selection,
				root = root
			};
		}

		private void UpdateSelectionPreview()
		{
			//IL_0028: 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_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_0057: 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_0071: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_selectionPreviewRoot == (Object)null) && _selection != null)
			{
				_selectionPreviewRoot.transform.position = AreaTool.AimPoint + Vector3.up * 4f;
				_selectionPreviewRoot.transform.rotation = _selection.AnchorRotation * Quaternion.Euler(0f, _selectionPreviewYawOffset, 0f);
			}
		}

		private void EnsureSavePanel()
		{
			//IL_0046: 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_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: 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_012c: 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_0167: 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_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: 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_01bb: 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_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_0289: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Expected O, but got Unknown
			//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f6: Expected O, but got Unknown
			//IL_0308: Unknown result type (might be due to invalid IL or missing references)
			//IL_0317: Unknown result type (might be due to invalid IL or missing references)
			//IL_0326: Unknown result type (might be due to invalid IL or missing references)
			//IL_0334: Unknown result type (might be due to invalid IL or missing references)
			//IL_033a: Unknown result type (might be due to invalid IL or missing references)
			if ((!((Object)(object)_savePanel != (Object)null) || !Object.op_Implicit((Object)(object)_savePanel)) && !((Object)(object)GUIManager.CustomGUIFront == (Object)null))
			{
				GUIManager instance = GUIManager.Instance;
				_savePanel = instance.CreateWoodpanel(GUIManager.CustomGUIFront.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), Vector2.zero, 382f, 214f, true);
				((Object)_savePanel).name = "HomesteadBlueprintSavePanel";
				Transform transform = _savePanel.transform;
				instance.CreateText(HomesteadLocalization.Text("hs_blueprint_save_title"), transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -28f), instance.AveriaSerifBold, 20, instance.ValheimOrange, true, Color.black, 320f, 28f, false);
				_saveCountText = instance.CreateText("", transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -62f), instance.AveriaSerif, 15, instance.ValheimBeige, true, Color.black, 320f, 24f, false).GetComponent<Text>();
				instance.CreateText(HomesteadLocalization.Text("hs_blueprint_name_label"), transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -88f), instance.AveriaSerifBold, 15, instance.ValheimOrange, true, Color.black, 320f, 22f, false);
				GameObject val = instance.CreateInputField(transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -122f), (ContentType)0, HomesteadLocalization.Text("hs_blueprint_name_placeholder"), 16, 292f, 34f);
				_saveNameInput = val.GetComponent<InputField>();
				_saveNameInput.characterLimit = 64;
				((UnityEvent<string>)(object)_saveNameInput.onValueChanged).AddListener((UnityAction<string>)delegate(string value)
				{
					_saveName = value;
				});
				((UnityEvent)instance.CreateButton(HomesteadLocalization.Text("hs_common_save"), transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(-76f, -166f), 132f, 34f).GetComponent<Button>().onClick).AddListener(new UnityAction(SaveSelectionFromUi));
				((UnityEvent)instance.CreateButton(HomesteadLocalization.Text("hs_common_clear"), transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(76f, -166f), 132f, 34f).GetComponent<Button>().onClick).AddListener(new UnityAction(ClearSelectionInternal));
				_saveStatusText = instance.CreateText("", transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -197f), instance.AveriaSerif, 14, instance.ValheimYellow, true, Color.black, 320f, 22f, false).GetComponent<Text>();
				RefreshSavePanel();
			}
		}

		private void UpdateSavePanel()
		{
			if (_selection == null)
			{
				SetSaveUiInputBlocked(blocked: false);
				SetSavePanelVisible(visible: false);
				return;
			}
			EnsureSavePanel();
			RefreshSavePanel();
			SetSavePanelVisible((Object)(object)_savePanel != (Object)null);
			bool saveUiInputBlocked = (Object)(object)_saveNameInput != (Object)null && _saveNameInput.isFocused;
			SetSaveUiInputBlocked(saveUiInputBlocked);
			if (_focusSaveName && (Object)(object)_saveNameInput != (Object)null)
			{
				_saveNameInput.ActivateInputField();
				_focusSaveName = false;
			}
		}

		private void RefreshSavePanel()
		{
			if (!((Object)(object)_savePanel == (Object)null))
			{
				if ((Object)(object)_saveNameInput != (Object)null && _saveNameInput.text != _saveName)
				{
					_saveNameInput.text = _saveName;
				}
				if ((Object)(object)_saveCountText != (Object)null)
				{
					_saveCountText.text = HomesteadLocalization.Format("hs_blueprint_selected_count", _selection?.Zdos.Count ?? 0);
				}
				if ((Object)(object)_saveStatusText != (Object)null)
				{
					_saveStatusText.text = _saveStatus;
				}
			}
		}

		private void SetSavePanelVisible(bool visible)
		{
			if ((Object)(object)_savePanel != (Object)null && _savePanel.activeSelf != visible)
			{
				_savePanel.SetActive(visible);
			}
		}

		private void DestroySavePanel()
		{
			if ((Object)(object)_savePanel != (Object)null)
			{
				Object.Destroy((Object)(object)_savePanel);
				_savePanel = null;
				_saveNameInput = null;
				_saveCountText = null;
				_saveStatusText = null;
			}
		}

		private void ReleaseSaveNameFocus()
		{
			if (!((Object)(object)_saveNameInput == (Object)null))
			{
				_saveNameInput.DeactivateInputField();
			}
		}

		private bool IsSaveNameInputFocused()
		{
			if ((Object)(object)_saveNameInput != (Object)null)
			{
				return _saveNameInput.isFocused;
			}
			return false;
		}

		private void SetSaveUiInputBlocked(bool blocked)
		{
			if (_saveInputBlocked != blocked)
			{
				GUIManager.BlockInput(blocked);
				_saveInputBlocked = blocked;
			}
		}

		private static string GenerateDefaultBlueprintName()
		{
			HashSet<string> hashSet;
			try
			{
				hashSet = ZoneBlueprintCommands.GetBlueprintNames().ToHashSet<string>(StringComparer.OrdinalIgnoreCase);
			}
			catch
			{
				hashSet = new HashSet<string>();
			}
			for (int i = 1; i <= 9999; i++)
			{
				string text = $"blueprint_{i:D3}";
				if (!hashSet.Contains(text))
				{
					return text;
				}
			}
			return "blueprint_" + DateTime.Now.ToString("yyyyMMdd_HHmmss", CultureInfo.InvariantCulture);
		}

		private GameObject? CreateVisualPreview(GameObject prefab, Vector3 localPosition, Quaternion localRotation, Vector3 scale, int index, Transform parent)
		{
			//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_0003: Unknown result type (might be due to invalid IL or missing references)
			return ZoneBlueprintPreviewBuilder.CreateVisualPreview(prefab, localPosition, localRotation, scale, index, parent);
		}

		private void ClearPreviewLines()
		{
			if (_previewBuildCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_previewBuildCoroutine);
				_previewBuildCoroutine = null;
			}
			if ((Object)(object)_selectionPreviewRoot != (Object)null)
			{
				Object.Destroy((Object)(object)_selectionPreviewRoot);
				_selectionPreviewRoot = null;
			}
			foreach (GameObject previewVisual in _previewVisuals)
			{
				if ((Object)(object)previewVisual != (Object)null)
				{
					Object.Destroy((Object)(object)previewVisual);
				}
			}
			_previewVisuals.Clear();
		}

		private void QueueIconRenderInternal(string blueprintName, ZoneBlueprintFile? blueprint)
		{
			if (string.IsNullOrWhiteSpace(blueprintName))
			{
				return;
			}
			if (blueprint != null)
			{
				_queuedIconBlueprints[blueprintName] = blueprint;
			}
			if (_queuedIconRenders.Add(blueprintName))
			{
				_iconRenderQueue.Enqueue(blueprintName);
				if (_iconRenderCoroutine == null)
				{
					_iconRenderCoroutine = ((MonoBehaviour)this).StartCoroutine(RenderQueuedIcons());
				}
			}
		}

		[IteratorStateMachine(typeof(<RenderQueuedIcons>d__73))]
		private IEnumerator RenderQueuedIcons()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RenderQueuedIcons>d__73(0)
			{
				<>4__this = this
			};
		}

		private static bool ShouldDelayIconRenderForPlacement()
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null && ((Character)localPlayer).InPlaceMode())
			{
				return !Hud.IsPieceSelectionVisible();
			}
			return false;
		}

		private static void Message(Player player, string message)
		{
			Message(player, message, (MessageType)1);
		}

		private static void Message(Player player, string message, MessageType type)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			ManualLogSource? logger = _logger;
			if (logger != null)
			{
				logger.LogInfo((object)message);
			}
			((Character)player).Message(type, message, 0, (Sprite)null);
		}
	}
	internal sealed class ZoneBlueprintSaveToolMarker : MonoBehaviour
	{
		public ZoneBlueprintToolKind Kind;

		public string BlueprintName = "";
	}
	internal enum ZoneBlueprintToolKind
	{
		AreaSave,
		AreaDismantle,
		Blueprint,
		Store
	}
	internal static class ZoneBlueprintSaveToolMenu
	{
		private static class ZoneBlueprintStoreHoverPrompt
		{
			private static GameObject? _root;

			private static Text? _text;

			private static float _hideAt;

			public static void Show(string message)
			{
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_007d: 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_00b3: 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)
				Ensure();
				if (!((Object)(object)_root == (Object)null) && !((Object)(object)_text == (Object)null))
				{
					_text.text = Localization.instance.Localize(message);
					_root.SetActive(true);
					_hideAt = Time.unscaledTime + 0.12f;
					RectTransform val = (RectTransform)_root.transform;
					Vector3 val2 = Input.mousePosition + new Vector3(18f, 28f, 0f);
					val2.x = Mathf.Clamp(val2.x, 8f, Mathf.Max(8f, (float)Screen.width - 420f - 8f));
					val2.y = Mathf.Clamp(val2.y, 29f, (float)Screen.height - 21f - 8f);
					((Transform)val).position = val2;
				}
			}

			public static void Update()
			{
				if ((Object)(object)_root != (Object)null && Object.op_Implicit((Object)(object)_root) && _root.activeSelf && Time.unscaledTime > _hideAt)
				{
					_root.SetActive(false);
				}
			}

			private static void Ensure()
			{
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Expected O, but got Unknown
				//IL_008d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0092: 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_00a7: 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_00bc: 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_00db: 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_0127: 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_013b: 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)
				if ((!((Object)(object)_root != (Object)null) || !Object.op_Implicit((Object)(object)_root) || !((Object)(object)_text != (Object)null) || !Object.op_Implicit((Object)(object)_text)) && !((Object)(object)GUIManager.CustomGUIFront == (Object)null))
				{
					GUIManager instance = GUIManager.Instance;
					_root = new GameObject("HomesteadBlueprintStoreHoverPrompt", new Type[1] { typeof(RectTransform) });
					_root.transform.SetParent(GUIManager.CustomGUIFront.transform, false);
					RectTransform val = (RectTransform)_root.transform;
					val.anchorMin = new Vector2(0f, 0f);
					val.anchorMax = new Vector2(0f, 0f);
					val.pivot = new Vector2(0f, 0.5f);
					val.sizeDelta = new Vector2(420f, 42f);
					((Graphic)_root.AddComponent<Image>()).color = new Color(0.02f, 0.02f, 0.02f, 0.82f);
					_text = instance.CreateText("", _root.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), Vector2.zero, instance.AveriaSerifBold, 17, instance.ValheimOrange, true, Color.black, 390f, 30f, false).GetComponent<Text>();
					_text.alignment = (TextAnchor)4;
					_root.SetActive(false);
				}
			}
		}

		[HarmonyPatch(typeof(PieceTable), "UpdateAvailable")]
		private static class PieceTableUpdateAvailablePatch
		{
			[HarmonyPriority(600)]
			private static void Prefix(PieceTable __instance)
			{
				if ((Object)(object)__instance != (Object)null && LooksLikeHammerTable(__instance))
				{
					EnsureBlueprintPiecesInHammerTable(__instance);
					if (_forceHammerRefreshOnNextTableUpdate)
					{
						_forceHammerRefreshOnNextTableUpdate = false;
						RequestHammerTableRefresh();
					}
				}
			}

			[HarmonyPriority(0)]
			private static void Postfix(PieceTable __instance)
			{
				if ((Object)(object)__instance != (Object)null && LooksLikeHammerTable(__instance))
				{
					EnsureBlueprintPiecesVisibleInHammerTable(__instance);
				}
			}
		}

		[HarmonyPatch(typeof(Hud), "UpdateBuild")]
		private static class HudUpdateBuildCategoryLabelPatch
		{
			[HarmonyPriority(800)]
			private static void Prefix()
			{
				Player localPlayer = Player.m_localPlayer;
				PieceTable val = (((Object)(object)localPlayer != (Object)null) ? localPlayer.m_buildPieces : null);
				if ((Object)(object)val != (Object)null && LooksLikeHammerTable(val))
				{
					EnsureCategoryLabels(val);
				}
			}
		}

		[HarmonyPatch(typeof(Player), "UpdateKnownRecipesList")]
		private static class PlayerUpdateKnownRecipesListCleanupPatch
		{
			[HarmonyPriority(800)]
			private static void Prefix(Player __instance)
			{
				if ((Object)(object)__instance == (Object)(object)Player.m_localPlayer)
				{
					SanitizeLocalPlayerPieceTables(removeBlueprintPieces: true);
				}
			}
		}

		[HarmonyPatch(typeof(Hud), "SetupPieceInfo")]
		private static class HudSetupPieceInfoPatch
		{
			private static void Postfix(Hud __instance, Piece piece)
			{
				if ((Object)(object)__instance == (Object)null || (Object)(object)piece == (Object)null || (Object)(object)__instance.m_hoveredPiece != (Object)(object)piece)
				{
					return;
				}
				ZoneBlueprintSaveToolMarker marker = GetMarker(piece);
				if (!((Object)(object)marker == (Object)null) && marker.Kind == ZoneBlueprintToolKind.Blueprint && !((Object)(object)__instance.m_pieceDescription == (Object)null))
				{
					ZoneBlueprintStoreHoverPrompt.Show(HomesteadLocalization.Format("hs_blueprint_store_hover", GetStoreListInputLabel()));
					if (IsStoreListClickDown())
					{
						TryOpenStoreListing(marker.BlueprintName);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Player), "SetSelectedPiece", new Type[] { typeof(Vector2Int) })]
		private static class PlayerSetSelectedPiecePatch
		{
			private static bool Prefix(Player __instance, Vector2Int p)
			{
				//IL_0013: 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)
				PieceTable buildPieces = __instance.m_buildPieces;
				if ((Object)(object)buildPieces == (Object)null)
				{
					return true;
				}
				ZoneBlueprintSaveToolMarker marker = GetMarker(buildPieces.GetPiece(p));
				if ((Object)(object)marker == (Object)null)
				{
					ZoneBlueprintStorePreviewTool.DeactivateActive();
					return true;
				}
				if (TryHandleStoreListingIntent(marker) || (marker.Kind == ZoneBlueprintToolKind.Blueprint && IsPrimaryClickDownOrHeld() && IsAnyBlueprintMenuModifierHeld()))
				{
					return false;
				}
				ZoneBlueprintStorePreviewTool.DeactivateActive();
				buildPieces.SetSelected(p);
				__instance.m_placePressedTime = -9998f;
				if (marker.Kind == ZoneBlueprintToolKind.AreaSave)
				{
					ZoneAreaDismantleTool.Deactivate();
					ZoneBlueprintPlacementTool.Deactivate();
					ZoneBlueprintSaveTool.Activate(__instance);
				}
				else if (marker.Kind == ZoneBlueprintToolKind.AreaDismantle)
				{
					ZoneBlueprintSaveTool.Deactivate();
					ZoneBlueprintPlacementTool.Deactivate();
					ZoneAreaDismantleTool.Activate(__instance);
				}
				else if (marker.Kind == ZoneBlueprintToolKind.Store)
				{
					ZoneBlueprintSaveTool.Deactivate();
					ZoneAreaDismantleTool.Deactivate();
					ZoneBlueprintPlacementTool.Deactivate();
					ZoneBlueprintStore.Open(__instance);
				}
				else
				{
					ZoneBlueprintSaveTool.Deactivate();
					ZoneAreaDismantleTool.Deactivate();
					ZoneBlueprintPlacementTool.Activate(__instance, marker.BlueprintName);
				}
				Hud.HidePieceSelection();
				return false;
			}
		}

		[HarmonyPatch(typeof(Player), "SetupPlacementGhost")]
		private static class PlayerSetupPlacementGhostPatch
		{
			private static bool Prefix(Player __instance)
			{
				PieceTable buildPieces = __instance.m_buildPieces;
				ZoneBlueprintSaveToolMarker marker = GetMarker((buildPieces != null) ? buildPieces.GetSelectedPiece() : null);
				if ((Object)(object)marker == (Object)null)
				{
					ZoneBlueprintStorePreviewTool.DeactivateActive();
					ZoneBlueprintSaveTool.Deactivate();
					ZoneAreaDismantleTool.Deactivate();
					ZoneBlueprintPlacementTool.Deactivate();
					return true;
				}
				if (TryHandleStoreListingIntent(marker))
				{
					if ((Object)(object)__instance.m_placementGhost != (Object)null)
					{
						Object.Destroy((Object)(object)__instance.m_placementGhost);
						__instance.m_placementGhost = null;
					}
					return false;
				}
				ZoneBlueprintStorePreviewTool.DeactivateActive();
				if ((Object)(object)__instance.m_placementGhost != (Object)null)
				{
					Object.Destroy((Object)(object)__instance.m_placementGhost);
					__instance.m_placementGhost = null;
				}
				if (marker.Kind == ZoneBlueprintToolKind.AreaSave)
				{
					ZoneAreaDismantleTool.Deactivate();
					ZoneBlueprintPlacementTool.Deactivate();
					ZoneBlueprintSaveTool.Activate(__instance);
				}
				else if (marker.Kind == ZoneBlueprintToolKind.AreaDismantle)
				{
					ZoneBlueprintSaveTool.Deactivate();
					ZoneBlueprintPlacementTool.Deactivate();
					ZoneAreaDismantleTool.Activate(__instance);
				}
				else if (marker.Kind == ZoneBlueprintToolKind.Store)
				{
					ZoneBlueprintSaveTool.Deactivate();
					ZoneAreaDismantleTool.Deactivate();
					ZoneBlueprintPlacementTool.Deactivate();
					ZoneBlueprintStore.Open(__instance);
				}
				else
				{
					ZoneBlueprintSaveTool.Deactivate();
					ZoneAreaDismantleTool.Deactivate();
					ZoneBlueprintPlacementTool.Activate(__instance, marker.BlueprintName);
				}
				return false;
			}
		}

		private const string CategoryId = "Homestead";

		private const string CategoryLabelKey = "hs_hammer_category";

		private const string ToolObjectName = "Homestead_BlueprintSaveTool";

		private const string DismantleToolObjectName = "Homestead_AreaDismantleTool";

		private const string StoreToolObjectName = "Homestead_BlueprintStoreTool";

		private const string HammerTable = "Hammer";

		private const float BlueprintListRefreshCooldownSeconds = 15f;

		private const float HammerRefreshDelaySeconds = 0.08f;

		private const float HammerRefreshBulkDelaySeconds = 0.75f;

		private const float HammerRefreshMinIntervalSeconds = 0.25f;

		private const int BlueprintPieceRegisterBudget = 64;

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

		private static readonly HashSet<string> RegisteredPrefabs = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private static readonly List<string> CachedBlueprintNames = new List<string>();

		private static readonly Queue<string> PendingBlueprintPieceNames = new Queue<string>();

		private static readonly HashSet<string> PendingBlueprintPieceNameSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private static readonly List<PieceTable> TempPieceTables = new List<PieceTable>();

		private static readonly object BlueprintDirectoryChangeLock = new object();

		private static readonly HashSet<string> PendingIconInvalidations = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private static FileSystemWatcher? _blueprintDirectoryWatcher;

		private static string _blueprintDirectoryWatcherPath = "";

		private static float _nextBlueprintDirectoryWatcherRetryAt;

		private static volatile bool _blueprintDirectoryChangePending;

		private static Sprite? _areaSaveIcon;

		private static Sprite? _areaDismantleIcon;

		private static Sprite? _storeIcon;

		private static Sprite? _fallbackIcon;

		private static Piece? _toolPiece;

		private static Piece? _dismantleToolPiece;

		private static Piece? _storeToolPiece;

		private static int _lastStoreListFrame = -1;

		private static int _storeListIntentFrame = -1;

		private static string _storeListIntentBlueprintName = "";

		private static bool _initialized;

		private static bool _blueprintListDirty = true;

		private static bool _blueprintRefreshRequested;

		private static float _nextBlueprintListRefreshAt;

		private static bool _hammerRefreshPending;

		private static bool _hammerRefreshUrgentPending;

		private static float _hammerRefreshAt;

		private static float _lastHammerRefreshAt = -999f;

		private static bool _forceHammerRefreshOnNextTableUpdate;

		private static string _pendingHammerRefreshHighlightName = "";

		private static int _lastBlueprintPieceRegisterFrame = -1;

		private static int _blueprintPiecesRegisteredThisFrame;

		private static PieceCategory _homesteadCategory = (PieceCategory)8;

		private static PieceCategory HomesteadCategory
		{
			get
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Invalid comparison between Unknown and I4
				//IL_001c: 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 ((int)_homesteadCategory == 8)
				{
					_homesteadCategory = PieceManager.Instance.AddPieceCategory("Homestead");
				}
				return _homesteadCategory;
			}
		}

		private static string CategoryLabel => HomesteadLocalization.Text("hs_hammer_category");

		public static void Initialize()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (!_initialized)
			{
				_initialized = true;
				_ = HomesteadCategory;
				EnsureToolPiece();
				EnsureDismantleToolPiece();
				EnsureStoreToolPiece();
			}
		}

		public static void Update()
		{
			EnsureBlueprintDirectoryWatcher();
			ProcessBlueprintDirectoryChange();
			ZoneBlueprintStoreHoverPrompt.Update();
			ProcessPendingBlueprintPieceRefresh();
			ProcessPendingHammerRefresh();
		}

		public static void ResetForWorldSession()
		{
			ClearBlueprintPiecesForWorldSession();
			CachedBlueprintNames.Clear();
			PendingBlueprintPieceNames.Clear();
			PendingBlueprintPieceNameSet.Clear();
			lock (BlueprintDirectoryChangeLock)
			{
				PendingIconInvalidations.Clear();
				_blueprintDirectoryChangePending = false;
			}
			DisposeBlueprintDirectoryWatcher();
			_blueprintListDirty = true;
			_blueprintRefreshRequested = true;
			_nextBlueprintListRefreshAt = 0f;
			_hammerRefreshPending = false;
			_hammerRefreshUrgentPending = false;
			_hammerRefreshAt = 0f;
			_lastHammerRefreshAt = -999f;
			_pendingHammerRefreshHighlightName = "";
			_lastBlueprintPieceRegisterFrame = -1;
			_blueprintPiecesRegisteredThisFrame = 0;
			_forceHammerRefreshOnNextTableUpdate = true;
		}

		public static bool IsToolPiece(Piece? piece)
		{
			if ((Object)(object)piece != (Object)null)
			{
				return (Object)(object)((Component)piece).GetComponent<ZoneBlueprintSaveToolMarker>() != (Object)null;
			}
			return false;
		}

		public static void InvalidateBlueprint(string name)
		{
			ZoneBlueprintVisuals.InvalidateIcon(name);
			MarkBlueprintListDirty();
			if (BlueprintPieces.TryGetValue(name, out Piece value) && Object.op_Implicit((Object)(object)value) && ZoneBlueprintCommands.TryLoadBlueprint(name, out ZoneBlueprintFile blueprint))
			{
				UpdateBlueprintPiece(value, name, blueprint);
			}
			RefreshBlueprintPieces(forceScan: true);
		}

		public static void RefreshAfterBlueprintSaved(string name, ZoneBlueprintFile blueprint, bool iconReady)
		{
			if (!iconReady)
			{
				ZoneBlueprintVisuals.InvalidateIcon(name);
			}
			Piece val = EnsureBlueprintPiece(name, blueprint, queueMissingIcon: false);
			MarkBlueprintListDirty();
			RefreshBlueprintPieces(forceScan: true);
			if ((Object)(object)val != (Object)null && Object.op_Implicit((Object)(object)val))
			{
				ForceRefreshLocalHammerTableNow(name);
			}
			else
			{
				RequestHammerTableRefresh(name);
			}
			if (!iconReady)
			{
				ZoneBlueprintSaveTool.QueueIconRender(name, blueprint);
			}
		}

		public static void ApplyBlueprintIcon(string name, Sprite? icon)
		{
			if (!((Object)(object)icon == (Object)null) && BlueprintPieces.TryGetValue(name, out Piece value) && !((Object)(object)value == (Object)null) && Object.op_Implicit((Object)(object)value))
			{
				value.m_icon = icon;
			}
		}

		public static void ForceRefreshLocalHammerTable(string? highlightName = null)
		{
			RequestHammerTableRefresh(highlightName);
		}

		public static void RequestHammerTableRefresh(string? highlightName = null)
		{
			RequestHammerTableRefresh(highlightName, deferForBatch: false);
		}

		private static void ForceRefreshLocalHammerTableNow(string? highlightName)
		{
			_pendingHammerRefreshHighlightName = "";
			_hammerRefreshPending = false;
			_hammerRefreshUrgentPending = false;
			if (!RefreshLocalHammerTableNow(highlightName))
			{
				RequestHammerTableRefresh(highlightName);
			}
		}

		private static void RequestHammerTableRefresh(string? highlightName, bool deferForBatch)
		{
			if (!string.IsNullOrWhiteSpace(highlightName))
			{
				_pendingHammerRefreshHighlightName = highlightName;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			float num = (deferForBatch ? 0.75f : 0.08f);
			float num2 = Mathf.Max(realtimeSinceStartup + num, _lastHammerRefreshAt + 0.25f);
			if (!_hammerRefreshPending)
			{
				_hammerRefreshAt = num2;
				_hammerRefreshUrgentPending = !deferForBatch;
			}
			else if (!deferForBatch)
			{
				_hammerRefreshAt = Mathf.Min(_hammerRefreshAt, num2);
				_hammerRefreshUrgentPending = true;
			}
			else if (!_hammerRefreshUrgentPending)
			{
				_hammerRefreshAt = Mathf.Max(_hammerRefreshAt, num2);
			}
			_hammerRefreshPending = true;
		}

		private static void ProcessPendingHammerRefresh()
		{
			if (_hammerRefreshPending && !(Time.realtimeSinceStartup < _hammerRefreshAt))
			{
				string pendingHammerRefreshHighlightName = _pendingHammerRefreshHighlightName;
				_pendingHammerRefreshHighlightName = "";
				_hammerRefreshPending = false;
				_hammerRefreshUrgentPending = false;
				RefreshLocalHammerTableNow(pendingHammerRefreshHighlightName);
			}
		}

		private static bool RefreshLocalHammerTableNow(string? highlightName = null)
		{
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return false;
			}
			PieceTable buildPieces = localPlayer.m_buildPieces;
			if ((Object)(object)buildPieces == (Object)null || !LooksLikeHammerTable(buildPieces))
			{
				return false;
			}
			Stopwatch stopwatch = Stopwatch.StartNew();
			EnsureToolPiece();
			EnsureDismantleToolPiece();
			EnsureStoreToolPiece();
			bool flag = false;
			bool flag2 = false;
			if ((Object)(object)_toolPiece != (Object)null && Object.op_Implicit((Object)(object)_toolPiece))
			{
				flag |= EnsurePieceInTable(buildPieces, _toolPiece);
			}
			if ((Object)(object)_dismantleToolPiece != (Object)null && Object.op_Implicit((Object)(object)_dismantleToolPiece))
			{
				flag |= EnsurePieceInTable(buildPieces, _dismantleToolPiece);
			}
			if ((Object)(object)_storeToolPiece != (Object)null && Object.op_Implicit((Object)(object)_storeToolPiece))
			{
				flag |= EnsurePieceInTable(buildPieces, _storeToolPiece);
			}
			foreach (Piece value2 in BlueprintPieces.Values)
			{
				if ((Object)(object)value2 != (Object)null && Object.op_Implicit((Object)(object)value2))
				{
					flag |= EnsurePieceInTable(buildPieces, value2);
				}
			}
			if (flag)
			{
				localPlayer.UpdateKnownRecipesList();
			}
			bool flag3 = flag || !string.IsNullOrWhiteSpace(highlightName);
			if (flag3)
			{
				localPlayer.UpdateAvailablePiecesList();
				EnsureBlueprintPiecesVisibleInHammerTable(buildPieces);
			}
			if (highlightName != null && highlightName.Length > 0)
			{
				if (BlueprintPieces.TryGetValue(highlightName, out Piece value) && (Object)(object)value != (Object)null && Object.op_Implicit((Object)(object)value))
				{
					EnsureCategoryLabels(buildPieces);
					int num = buildPieces.m_categories.IndexOf(value.m_category);
					if (num >= 0)
					{
						buildPieces.SetCategory(num);
						flag2 = true;
					}
				}
			}
			flag3 = flag3 || flag2;
			if (flag3)
			{
				RefreshVisiblePieceSelection(localPlayer);
			}
			_lastHammerRefreshAt = Time.realtimeSinceStartup;
			stopwatch.Stop();
			HomesteadPlugin.HomesteadLogger.LogDebug((object)$"Homestead hammer table refresh completed in {stopwatch.Elapsed.TotalMilliseconds:0.0} ms; blueprints={BlueprintPieces.Count}; tableChanged={flag}; visibleSelectionChanged={flag2}; availableListRefreshNeeded={flag3}.");
			return true;
		}

		public static bool IsToolSelected(Player player)
		{
			PieceTable buildPieces = player.m_buildPieces;
			if ((Object)(object)buildPieces != (Object)null)
			{
				return IsToolPiece(buildPieces.GetSelectedPiece());
			}
			return false;
		}

		public static bool IsStoreToolSelected(Player? player)
		{
			PieceTable obj = player?.m_buildPieces;
			ZoneBlueprintSaveToolMarker marker = GetMarker((obj != null) ? obj.GetSelectedPiece() : null);
			if (marker != null)
			{
				return marker.Kind == ZoneBlueprintToolKind.Store;
			}
			return false;
		}

		private static ZoneBlueprintSaveToolMarker? GetMarker(Piece? piece)
		{
			if (!((Object)(object)piece == (Object)null))
			{
				return ((Component)piece).GetComponent<ZoneBlueprintSaveToolMarker>();
			}
			return null;
		}

		public static void RefreshBlueprintPieces(bool forceScan = false, bool processNow = true)
		{
			Initialize();
			if ((Object)(object)ZNetScene.instance == (Object)null)
			{
				return;
			}
			if (forceScan)
			{
				MarkBlueprintListDirty();
			}
			if (forceScan || _blueprintListDirty || PendingBlueprintPieceNames.Count != 0 || !(Time.realtimeSinceStartup < _nextBlueprintListRefreshAt))
			{
				_blueprintRefreshRequested = true;
				if (processNow)
				{
					ProcessPendingBlueprintPieceRefresh();
				}
			}
		}

		private static void MarkBlueprintListDirty()
		{
			_blueprintListDirty = true;
			_nextBlueprintListRefreshAt = 0f;
			_blueprintRefreshRequested = true;
		}

		private static void ProcessPendingBlueprintPieceRefresh()
		{
			if ((Object)(object)ZNetScene.instance == (Object)null || (!_blueprintRefreshRequested && PendingBlueprintPieceNames.Count == 0))
			{
				return;
			}
			if (_blueprintRefreshRequested)
			{
				TryRefreshBlueprintNameCache();
			}
			if (_lastBlueprintPieceRegisterFrame != Time.frameCount)
			{
				_lastBlueprintPieceRegisterFrame = Time.frameCount;
				_blueprintPiecesRegisteredThisFrame = 0;
			}
			int num = 64 - _blueprintPiecesRegisteredThisFrame;
			bool flag = false;
			string highlightName = "";
			while (num > 0 && PendingBlueprintPieceNames.Count > 0)
			{
				string text = PendingBlueprintPieceNames.Dequeue();
				PendingBlueprintPieceNameSet.Remove(text);
				if (BlueprintPieces.TryGetValue(text, out Piece value) && Object.op_Implicit((Object)(object)value))
				{
					flag = true;
					continue;
				}
				Stopwatch stopwatch = Stopwatch.StartNew();
				Piece val = EnsureBlueprintPiece(text);
				stopwatch.Stop();
				num--;
				_blueprintPiecesRegisteredThisFrame++;
				if ((Object)(object)val != (Object)null && Object.op_Implicit((Object)(object)val))
				{
					flag = true;
					highlightName = text;
					HomesteadPlugin.HomesteadLogger.LogDebug((object)$"Homestead blueprint piece registered '{text}' in {stopwatch.Elapsed.TotalMilliseconds:0.0} ms; pending={PendingBlueprintPieceNames.Count}.");
				}
			}
			if (flag)
			{
				RequestHammerTableRefresh(highlightName, PendingBlueprintPieceNames.Count > 0);
			}
		}

		private static void TryRefreshBlueprintNameCache()
		{
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (!_blueprintListDirty && realtimeSinceStartup < _nextBlueprintListRefreshAt)
			{
				return;
			}
			try
			{
				Stopwatch stopwatch = Stopwatch.StartNew();
				List<string> blueprintNames = ZoneBlueprintCommands.GetBlueprintNames();
				HashSet<string> currentNames = blueprintNames.ToHashSet<string>(StringComparer.OrdinalIgnoreCase);
				int num = RemoveMissingBlueprintPieces(currentNames);
				RemoveStalePendingBlueprintPieces(currentNames);
				CachedBlueprintNames.Clear();
				CachedBlueprintNames.AddRange(blueprintNames);
				int num2 = 0;
				foreach (string cachedBlueprintName in CachedBlueprintNames)
				{
					if ((!BlueprintPieces.TryGetValue(cachedBlueprintName, out Piece value) || !Object.op_Implicit((Object)(object)value)) && PendingBlueprintPieceNameSet.Add(cachedBlueprintName))
					{
						PendingBlueprintPieceNames.Enqueue(cachedBlueprintName);
						num2++;
					}
				}
				_blueprintListDirty = false;
				_blueprintRefreshRequested = false;
				_nextBlueprintListRefreshAt = realtimeSinceStartup + 15f;
				stopwatch.Stop();
				if (num > 0)
				{
					SanitizeLocalPlayerPieceTables(removeBlueprintPieces: true);
					RequestHammerTableRefresh();
				}
				HomesteadPlugin.HomesteadLogger.LogDebug((object)$"Homestead blueprint file scan completed in {stopwatch.Elapsed.TotalMilliseconds:0.0} ms; names={blueprintNames.Count}, queued={num2}, removed={num}.");
			}
			catch (Exception ex)
			{
				_blueprintRefreshRequested = false;
				_nextBlueprintListRefreshAt = realtimeSinceStartup + 15f;
				HomesteadPlugin.HomesteadLogger.LogDebug((object)("Could not refresh Homestead blueprint pieces yet: " + ex.Message));
			}
		}

		private static void EnsureBlueprintDirectoryWatcher()
		{
			if (Time.realtimeSinceStartup < _nextBlueprintDirectoryWatcherRetryAt)
			{
				return;
			}
			string blueprintStorageFullPath = HomesteadPlugin.BlueprintStorageFullPath;
			if (string.IsNullOrWhiteSpace(blueprintStorageFullPath) || !Directory.Exists(blueprintStorageFullPath))
			{
				_nextBlueprintDirectoryWatcherRetryAt = Time.realtimeSinceStartup + 2f;
			}
			else if (_blueprintDirectoryWatcher == null || !string.Equals(_blueprintDirectoryWatcherPath, blueprintStorageFullPath, StringComparison.OrdinalIgnoreCase))
			{
				DisposeBlueprintDirectoryWatcher();
				try
				{
					FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(blueprintStorageFullPath);
					fileSystemWatcher.Filter = "*.hsbp.*";
					fileSystemWatcher.IncludeSubdirectories = false;
					fileSystemWatcher.NotifyFilter = NotifyFilters.FileName | NotifyFilters.Size | NotifyFilters.LastWrite;
					fileSystemWatcher.Created += OnBlueprintDirectoryChanged;
					fileSystemWatcher.Changed += OnBlueprintDirectoryChanged;
					fileSystemWatcher.Deleted += OnBlueprintDirectoryChanged;
					fileSystemWatcher.Renamed += OnBlueprintDirectoryRenamed;
					fileSystemWatcher.EnableRaisingEvents = true;
					_blueprintDirectoryWatcher = fileSystemWatcher;
					_blueprintDirectoryWatcherPath = blueprintStorageFullPath;
				}
				catch (Exception ex)
				{
					_nextBlueprintDirectoryWatcherRetryAt = Time.realtimeSinceStartup + 5f;
					HomesteadPlugin.HomesteadLogger.LogDebug((object)("Could not watch Homestead blueprint directory yet: " + ex.Message));
				}
			}
		}

		private static void OnBlueprintDirectoryChanged(object sender, FileSystemEventArgs args)
		{
			if (IsBlueprintFile(args.FullPath))
			{
				QueueBlueprintDirectoryChange(args.FullPath, null);
			}
		}

		private static void OnBlueprintDirectoryRenamed(object sender, RenamedEventArgs args)
		{
			if (IsBlueprintFile(args.FullPath) || IsBlueprintFile(args.OldFullPath))
			{
				QueueBlueprintDirectoryChange(args.FullPath, args.OldFullPath);
			}
		}

		private static void ProcessBlueprintDirectoryChange()
		{
			List<string> list = new List<string>();
			lock (BlueprintDirectoryChangeLock)
			{
				if (!_blueprintDirectoryChangePending)
				{
					return;
				}
				_blueprintDirectoryChangePending = false;
				list.AddRange(PendingIconInvalidations);
				PendingIconInvalidations.Clear();
			}
			foreach (string item in list)
			{
				ZoneBlueprintVisuals.InvalidateIcon(item);
				if (BlueprintPieces.TryGetValue(item, out Piece value) && (Object)(object)value != (Object)null && Object.op_Implicit((Object)(object)value) && ZoneBlueprintCommands.TryLoadBlueprint(item, out ZoneBlueprintFile blueprint))
				{
					UpdateBlueprintPiece(value, item, blueprint, queueMissingIcon: false);
				}
			}
			MarkBlueprintListDirty();
			RequestHammerTableRefresh();
		}

		private static void QueueBlueprintDirectoryChange(string path, string? oldPath)
		{
			lock (BlueprintDirectoryChangeLock)
			{
				_blueprintDirectoryChangePending = true;
				AddPendingIconInvalidation(path);
				if (!string.IsNullOrWhiteSpace(oldPath))
				{
					AddPendingIconInvalidation(oldPath);
				}
			}
		}

		private static void AddPendingIconInvalidation(string path)
		{
			if (IsBlueprintPng(path))
			{
				string fileName = Path.GetFileName(path);
				if (fileName.Length > ".hsbp.png".Length)
				{
					PendingIconInvalidations.Add(fileName.Substring(0, fileName.Length - ".hsbp.png".Length));
				}
			}
		}

		private static bool IsBlueprintFile(string path)
		{
			string fileName = Path.GetFileName(path);
			if (!fileName.EndsWith(".hsbp.yml", StringComparison.OrdinalIgnoreCase))
			{
				return fileName.EndsWith(".hsbp.png", StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}

		private static bool IsBlueprintPng(string path)
		{
			return Path.GetFileName(path).EndsWith(".hsbp.png", StringComparison.OrdinalIgnoreCase);
		}

		private static void DisposeBlueprintDirectoryWatcher()
		{
			if (_blueprintDirectoryWatcher != null)
			{
				_blueprintDirectoryWatcher.EnableRaisingEvents = false;
				_blueprintDirectoryWatcher.Created -= OnBlueprintDirectoryChanged;
				_blueprintDirectoryWatcher.Changed -= OnBlueprintDirectoryChanged;
				_blueprintDirectoryWatcher.Deleted -= OnBlueprintDirectoryChanged;
				_blueprintDirectoryWatcher.Renamed -= OnBlueprintDirectoryRenamed;
				_blueprintDirectoryWatcher.Dispose();
				_blueprintDirectoryWatcher = null;
				_blueprintDirectoryWatcherPath = "";
			}
		}

		private static int RemoveMissingBlueprintPieces(HashSet<string> currentNames)
		{
			HashSet<string> currentNames2 = currentNames;
			List<string> list = BlueprintPieces.Keys.Where((string name) => !currentNames2.Contains(name)).ToList();
			foreach (string item in list)
			{
				if (BlueprintPieces.TryGetValue(item, out Piece value))
				{
					BlueprintPieces.Remove(item);
					if ((Object)(object)value != (Object)null && Object.op_Implicit((Object)(object)value) && (Object)(object)((Component)value).gameObject != (Object)null && Object.op_Implicit((Object)(object)((Component)value).gameObject))
					{
						RegisteredPrefabs.Remove(((Object)((Component)value).gameObject).name);
						Object.Destroy((Object)(object)((Component)value).gameObject);
					}
				}
				RegisteredPrefabs.Remove("Homestead_Blueprint_" + SanitizePrefabName(item));
				ZoneBlueprintVisuals.InvalidateIcon(item);
			}
			return list.Count;
		}

		private static void RemoveStalePendingBlueprintPieces(HashSet<string> currentNames)
		{
			if (PendingBlueprintPieceNames.Count == 0)
			{
				return;
			}
			List<string> list = new List<string>();
			PendingBlueprintPieceNameSet.Clear();
			while (PendingBlueprintPieceNames.Count > 0)
			{
				string item = PendingBlueprintPieceNames.Dequeue();
				if (currentNames.Contains(item) && PendingBlueprintPieceNameSet.Add(item))
				{
					list.Add(item);
				}
			}
			foreach (string item2 in list)
			{
				PendingBlueprintPieceNames.Enqueue(item2);
			}
		}

		private static void ClearBlueprintPiecesForWorldSession()
		{
			SanitizeLocalPlayerPieceTables(removeBlueprintPieces: true);
			foreach (Piece value in BlueprintPieces.Values)
			{
				if ((Object)(object)value != (Object)null && Object.op_Implicit((Object)(object)value) && Object.op_Implicit((Object)(object)((Component)value).gameObject))
				{
					Object.Destroy((Object)(object)((Component)value).gameObject);
				}
			}
			BlueprintPieces.Clear();
			RegisteredPrefabs.RemoveWhere((string name) => name.StartsWith("Homestead_Blueprint_", StringComparison.OrdinalIgnoreCase));
		}

		private static void EnsureBlueprintPiecesInHammerTable(PieceTable table)
		{
			if ((Object)(object)table == (Object)null || !LooksLikeHammerTable(table))
			{
				return;
			}
			SanitizePieceTable(table, removeBlueprintPieces: false);
			RefreshBlueprintPieces();
			EnsureToolPiece();
			EnsureDismantleToolPiece();
			EnsureStoreToolPiece();
			if ((Object)(object)_toolPiece != (Object)null && Object.op_Implicit((Object)(object)_toolPiece))
			{
				EnsurePieceInTable(table, _toolPiece);
			}
			if ((Object)(object)_dismantleToolPiece != (Object)null && Object.op_Implicit((Object)(object)_dismantleToolPiece))
			{
				EnsurePieceInTable(table, _dismantleToolPiece);
			}
			if ((Object)(object)_storeToolPiece != (Object)null && Object.op_Implicit((Object)(object)_storeToolPiece))
			{
				EnsurePieceInTable(table, _storeToolPiece);
			}
			foreach (Piece value in BlueprintPieces.Values)
			{
				if ((Object)(object)value != (Object)null && Object.op_Implicit((Object)(object)value))
				{
					EnsurePieceInTable(table, value);
				}
			}
		}

		private static void EnsureBlueprintPiecesVisibleInHammerTable(PieceTable table)
		{
			if ((Object)(object)table == (Object)null || !LooksLikeHammerTable(table))
			{
				return;
			}
			EnsureCategoryLabels(table);
			EnsureAvailableCategorySlots(table);
			if ((Object)(object)_toolPiece != (Object)null && Object.op_Implicit((Object)(object)_toolPiece))
			{
				EnsurePieceVisibleInAvailableList(table, _toolPiece);
			}
			if ((Object)(object)_dismantleToolPiece != (Object)null && Object.op_Implicit((Object)(object)_dismantleToolPiece))
			{
				EnsurePieceVisibleInAvailableList(table, _dismantleToolPiece);
			}
			if ((Object)(object)_storeToolPiece != (Object)null && Object.op_Implicit((Object)(object)_storeToolPiece))
			{
				EnsurePieceVisibleInAvailableList(table, _storeToolPiece);
			}
			foreach (Piece value in BlueprintPieces.Values)
			{
				if ((Object)(object)value != (Object)null && Object.op_Implicit((Object)(object)value))
				{
					EnsurePieceVisibleInAvailableList(table, value);
				}
			}
		}

		public static bool TrySelectTool(Player player)
		{
			//IL_0047: 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_005d: Expected I4, but got Unknown
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			PieceTable buildPieces = player.m_buildPieces;
			if ((Object)(object)buildPieces == (Object)null || !LooksLikeHammerTable(buildPieces))
			{
				return false;
			}
			RefreshBlueprintPieces();
			player.UpdateAvailablePiecesList();
			if ((Object)(object)_toolPiece == (Object)null)
			{
				return false;
			}
			EnsureBlueprintPiecesVisibleInHammerTable(buildPieces);
			int num = buildPieces.m_categories.IndexOf(_toolPiece.m_category);
			int num2 = (int)_toolPiece.m_category;
			int num3 = ((num2 >= 0 && num2 < buildPieces.m_availablePieces.Count) ? buildPieces.m_availablePieces[num2].IndexOf(_toolPiece) : (-1));
			if (num < 0 || num3 < 0)
			{
				return false;
			}
			buildPieces.SetCategory(num);
			buildPieces.SetSelected(new Vector2Int(num3 % 15, num3 / 15));
			ZoneBlueprintSaveTool.Activate(player);
			ZoneAreaDismantleTool.Deactivate();
			ZoneBlueprintPlacementTool.Deactivate();
			Hud.HidePieceSelection();
			return true;
		}

		private static bool LooksLikeHammerTable(PieceTable table)
		{
			if (((Object)table).name.ToLowerInvariant().Contains("hammer"))
			{
				return true;
			}
			return table.m_pieces.Any((GameObject piece) => Object.op_Implicit((Object)(object)piece) && Utils.GetPrefabName(piece).Equals("piece_repair", StringComparison.OrdinalIgnoreCase));
		}

		private static void SanitizeLocalPlayerPieceTables(bool removeBlueprintPieces)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			if ((Object)(object)localPlayer.m_buildPieces != (Object)null && LooksLikeHammerTable(localPlayer.m_buildPieces))
			{
				SanitizePieceTable(localPlayer.m_buildPieces, removeBlueprintPieces);
			}
			TempPieceTables.Clear();
			Inventory inventory = ((Humanoid)localPlayer).m_inventory;
			if (inventory != null)
			{
				inventory.GetAllPieceTables(TempPieceTables);
			}
			foreach (PieceTable tempPieceTable in TempPieceTables)
			{
				if ((Object)(object)tempPieceTable != (Object)null && LooksLikeHammerTable(tempPieceTable))
				{
					SanitizePieceTable(tempPieceTable, removeBlueprintPieces);
				}
			}
			TempPieceTables.Clear();
		}

		private static void SanitizePieceTable(PieceTable table, bool removeBlueprintPieces)
		{
			if ((Object)(object)table == (Object)null)
			{
				return;
			}
			table.m_pieces.RemoveAll((GameObject pieceObject) => ShouldRemovePieceObject(pieceObject, removeBlueprintPieces));
			foreach (List<Piece> availablePiece in table.m_availablePieces)
			{
				availablePiece.RemoveAll((Piece piece) => ShouldRemoveAvailablePiece(piece, removeBlueprintPieces));
			}
		}

		private static bool ShouldRemovePieceObject(GameObject? pieceObject, bool removeBlueprintPieces)
		{
			if ((Object)(object)pieceObject == (Object)null || !Object.op_Implicit((Object)(object)pieceObject))
			{
				return true;
			}
			Piece component;
			try
			{
				component = pieceObject.GetComponent<Piece>();
			}
			catch
			{
				return true;
			}
			return ShouldRemoveAvailablePiece(component, removeBlueprintPieces);
		}

		private static bool ShouldRemoveAvailablePiece(Piece? piece, bool removeBlueprintPieces)
		{
			if ((Object)(object)piece == (Object)null || !Object.op_Implicit((Object)(object)piece) || (Object)(object)((Component)piece).gameObject == (Object)null || !Object.op_Implicit((Object)(object)((Component)piece).gameObject))
			{
				return true;
			}
			if (removeBlueprintPieces)
			{
				ZoneBlueprintSaveToolMarker marker = GetMarker(piece);
				if (marker != null)
				{
					return marker.Kind == ZoneBlueprintToolKind.Blueprint;
				}
				return false;
			}
			return false;
		}

		private static bool EnsurePieceInTable(PieceTable table, Piece piece)
		{
			//IL_0029: 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 ((Object)(object)piece == (Object)null || !Object.op_Implicit((Object)(object)piece) || !Object.op_Implicit((Object)(object)((Component)piece).gameObject))
			{
				return false;
			}
			bool flag = false;
			if (!table.m_categories.Contains(piece.m_category))
			{
				table.m_categories.Add(piece.m_category);
				flag = true;
			}
			flag |= EnsureCategoryLabels(table);
			if (!table.m_pieces.Contains(((Component)piece).gameObject))
			{
				table.m_pieces.Add(((Component)piece).gameObject);
				flag = true;
			}
			return flag;
		}

		private static bool EnsureCategoryLabels(PieceTable table)
		{
			//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)
			//IL_0023: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			while (table.m_categoryLabels.Count < table.m_categories.Count)
			{
				int count = table.m_categoryLabels.Count;
				PieceCategory val = table.m_categories[count];
				table.m_categoryLabels.Add((val == HomesteadCategory) ? CategoryLabel : ((object)(PieceCategory)(ref val)).ToString());
				flag = true;
			}
			int num = table.m_categories.IndexOf(HomesteadCategory);
			if (num >= 0 && num < table.m_categoryLabels.Count)
			{
				string categoryLabel = CategoryLabel;
				if (!string.Equals(table.m_categoryLabels[num], categoryLabel, StringComparison.Ordinal))
				{
					table.m_categoryLabels[num] = categoryLabel;
					flag = true;
				}
				flag |= MoveHomesteadCategoryToEnd(table, num);
			}
			return flag;
		}

		private static bool MoveHomesteadCategoryToEnd(PieceTable table, int homesteadIndex)
		{
			//IL_001f: 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_0037: Unknown result type (might be due to invalid IL or missing references)
			int num = table.m_categories.Count - 1;
			if (homesteadIndex < 0 || homesteadIndex >= num)
			{
				return false;
			}
			PieceCategory item = table.m_categories[homesteadIndex];
			table.m_categories.RemoveAt(homesteadIndex);
			table.m_categories.Add(item);
			if (homesteadIndex < table.m_categoryLabels.Count)
			{
				string item2 = table.m_categoryLabels[homesteadIndex];
				table.m_categoryLabels.RemoveAt(homesteadIndex);
				table.m_categoryLabels.Add(item2);
			}
			int num2 = table.m_categories.Count - 1;
			if (num2 >= 0 && num2 < table.m_categoryLabels.Count)
			{
				table.m_categoryLabels[num2] = CategoryLabel;
			}
			return true;
		}

		private static void EnsureAvailableCategorySlots(PieceTable table)
		{
			//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_0023: 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_002b: Expected I4, but got Unknown
			int num = table.m_categories.Count;
			foreach (PieceCategory category in table.m_categories)
			{
				num = Mathf.Max(num, category + 1);
			}
			while (table.m_availablePieces.Count < num)
			{
				table.m_availablePieces.Add(new List<Piece>());
			}
			if (table.m_selectedPiece.Length < num)
			{
				Array.Resize(ref table.m_selectedPiece, num);
			}
			if (table.m_lastSelectedPiece.Length < num)
			{
				Array.Resize(ref table.m_lastSelectedPiece, num);
			}
		}

		private static void EnsurePieceVisibleInAvailableList(PieceTable table, Piece piece)
		{
			//IL_0007: 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_0045: Expected I4, but got Unknown
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if (table.m_categories.IndexOf(piece.m_category) < 0)
			{
				if (EnsurePieceInTable(table, piece))
				{
					EnsureAvailableCategorySlots(table);
				}
				if (table.m_categories.IndexOf(piece.m_category) < 0)
				{
					return;
				}
			}
			EnsureAvailableCategorySlots(table);
			int num = (int)piece.m_category;
			if (num >= 0 && num < table.m_availablePieces.Count)
			{
				List<Piece> list = table.m_availablePieces[num];
				if (!list.Contains(piece))
				{
					list.Add(piece);
				}
			}
		}

		private static void RefreshVisiblePieceSelection(Player player)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			Hud instance = Hud.instance;
			if (!((Object)(object)instance == (Object)null) && instance.m_buildHud.activeSelf)
			{
				PieceTable buildPieces = player.m_buildPieces;
				if ((Object)(object)buildPieces != (Object)null && LooksLikeHammerTable(buildPieces))
				{
					EnsureCategoryLabels(buildPieces);
				}
				instance.m_lastPieceCategory = (PieceCategory)8;
				instance.UpdateBuild(player, true);
			}
		}

		private static void EnsureToolPiece()
		{
			//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_0057: Expected O, but got Unknown
			//IL_0057: 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_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			if ((Object)(object)_toolPiece != (Object)null && Object.op_Implicit((Object)(object)_toolPiece))
			{
				_toolPiece.m_icon = GetAreaSaveIcon();
				_toolPiece.m_description = FormatAreaSaveDescription();
				RegisterWithJotunn(((Component)_toolPiece).gameObject);
				return;
			}
			GameObject val = new GameObject("Homestead_BlueprintSaveTool");
			Object.DontDestroyOnLoad((Object)val);
			val.AddComponent<ZoneBlueprintSaveToolMarker>().Kind = ZoneBlueprintToolKind.AreaSave;
			Piece obj = val.AddComponent<Piece>();
			obj.m_name = HomesteadLocalization.Token("hs_area_save_name");
			obj.m_description = FormatAreaSaveDescription();
			obj.m_category = HomesteadCategory;
			obj.m_resources = Array.Empty<Requirement>();
			obj.m_icon = GetAreaSaveIcon();
			obj.m_enabled = true;
			obj.m_canRotate = false;
			obj.m_clipEverything = true;
			_toolPiece = obj;
			RegisterWithJotunn(val);
		}

		private static void EnsureDismantleToolPiece()
		{
			//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_0057: Expected O, but got Unknown
			//IL_0057: 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_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			if ((Object)(object)_dismantleToolPiece != (Object)null && Object.op_Implicit((Object)(object)_dismantleToolPiece))
			{
				_dismantleToolPiece.m_icon = GetAreaDismantleIcon();
				_dismantleToolPiece.m_description = FormatAreaDismantleDescription();
				RegisterWithJotunn(((Component)_dismantleToolPiece).gameObject);
				return;
			}
			GameObject val = new GameObject("Homestead_AreaDismantleTool");
			Object.DontDestroyOnLoad((Object)val);
			val.AddComponent<ZoneBlueprintSaveToolMarker>().Kind = ZoneBlueprintToolKind.AreaDismantle;
			Piece obj = val.AddComponent<Piece>();
			obj.m_name = HomesteadLocalization.Token("hs_area_dismantle_name");
			obj.m_description = FormatAreaDismantleDescription();
			obj.m_category = HomesteadCategory;
			obj.m_resources = Array.Empty<Requirement>();
			obj.m_icon = GetAreaDismantleIcon();
			obj.m_enabled = true;
			obj.m_canRotate = false;
			obj.m_clipEverything = true;
			_dismantleToolPiece = obj;
			RegisterWithJotunn(val);
		}

		private static void EnsureStoreToolPiece()
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00ba: Expected O, but got Unknown
			if ((Object)(object)_storeToolPiece != (Object)null && Object.op_Implicit((Object)(object)_storeToolPiece))
			{
				_storeToolPiece.m_icon = GetStoreIcon();
				RegisterWithJotunn(((Component)_storeToolPiece).gameObject);
				return;
			}
			GameObject val = new GameObject("Homestead_BlueprintStoreTool");
			Object.DontDestroyOnLoad((Object)val);
			val.AddComponent<ZoneBlueprintSaveToolMarker>().Kind = ZoneBlueprintToolKind.Store;
			Piece obj = val.AddComponent<Piece>();
			obj.m_name = HomesteadLocalization.Token("hs_blueprint_store_name");
			obj.m_description = HomesteadLocalization.Token("hs_blueprint_store_desc");
			obj.m_category = HomesteadCategory;
			obj.m_resources = Array.Empty<Requirement>();
			obj.m_icon = GetStoreIcon();
			obj.m_enabled = true;
			obj.m_canRotate = false;
			obj.m_clipEverything = true;
			_storeToolPiece = obj;
			RegisterWithJotunn(val);
		}

		private static string FormatAreaSaveDescription()
		{
			return HomesteadLocalization.Format("hs_area_save_desc", "Wheel", FormatAreaScaleInput(), FormatAreaDepthInput(), FormatAreaWidthInput(), "Mouse0") + "\n" + HomesteadLocalization.Text("hs_area_save_color_hint");
		}

		private static string FormatAreaDismantleDescription()
		{
			return HomesteadLocalization.Format("hs_area_dismantle_desc", "Wheel", FormatAreaScaleInput(), FormatAreaDepthInput(), FormatAreaWidthInput(), "Mouse0");
		}

		private static string FormatAreaScaleInput()
		{
			return ZoneAreaToolShared.FormatScaleInput();
		}

		private static string FormatAreaDepthInput()
		{
			return ZoneAreaToolShared.FormatDepthInput();
		}

		private static string FormatAreaWidthInput()
		{
			return ZoneAreaToolShared.FormatWidthInput();
		}

		private static Piece? EnsureBlueprintPiece(string name, ZoneBlueprintFile? loadedBlueprint = null, bool queueMissingIcon = true)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//IL_005e: 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_00a7: Expected O, but got Unknown
			if (BlueprintPieces.TryGetValue(name, out Piece value) && Object.op_Implicit((Object)(object)value))
			{
				if (loadedBlueprint != null)
				{
					UpdateBlueprintPiece(value, name, loadedBlueprint, queueMissingIcon);
				}
				RegisterWithJotunn(((Component)value).gameObject);
				return value;
			}
			ZoneBlueprintFile blueprint;
			if (loadedBlueprint != null)
			{
				blueprint = loadedBlueprint;
			}
			else if (!ZoneBlueprintCommands.TryLoadBlueprint(name, out blueprint))
			{
				return null;
			}
			GameObject val = new GameObject("Homestead_Blueprint_" + SanitizePrefabName(name));
			Object.DontDestroyOnLoad((Object)val);
			ZoneBlueprintSaveToolMarker zoneBlueprintSaveToolMarker = val.AddComponent<ZoneBlueprintSaveToolMarker>();
			zoneBlueprintSaveToolMarker.Kind = ZoneBlueprintToolKind.Blueprint;
			zoneBlueprintSaveToolMarker.BlueprintName = name;
			Piece val2 = val.AddComponent<Piece>();
			UpdateBlueprintPiece(val2, name, blueprint, queueMissingIcon);
			val2.m_enabled = true;
			val2.m_canRotate = false;
			val2.m_clipEverything = true;
			BlueprintPieces[name] = val2;
			RegisterWithJotunn(val);
			return val2;
		}

		private static void UpdateBlueprintPiece(Piece piece, string name, ZoneBlueprintFile blueprint, bool queueMissingIcon = true)
		{
			//IL_005b: 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)
			ZoneBlueprintSaveToolMarker obj = ((Component)piece).GetComponent<ZoneBlueprintSaveToolMarker>() ?? ((Component)piece).gameObject.AddComponent<ZoneBlueprintSaveToolMarker>();
			obj.Kind = ZoneBlueprintToolKind.Blueprint;
			obj.BlueprintName = name;
			piece.m_name = name;
			piece.m_description = HomesteadLocalization.Format("hs_blueprint_piece_desc", blueprint.Entries.Count, GetStoreListInputLabel());
			piece.m_category = HomesteadCategory;
			piece.m_resources = Array.Empty<Requirement>();
			Sprite icon;
			bool num = ZoneBlueprintVisuals.TryGetIcon(name, out icon);
			piece.m_icon = icon ?? GetFallbackIcon();
			if (!num && queueMissingIcon)
			{
				ZoneBlueprintSaveTool.QueueIconRender(name);
			}
		}

		private static void RegisterWithJotunn(GameObject prefab)
		{
			//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_007d: Expected O, but got Unknown
			if (!Object.op_Implicit((Object)(object)prefab) || RegisteredPrefabs.Contains(((Object)prefab).name))
			{
				return;
			}
			Piece component = prefab.GetComponent<Piece>();
			if ((Object)(object)component == (Object)null || (Object)(object)component.m_icon == (Object)null)
			{
				return;
			}
			ZoneBlueprintSaveToolMarker component2 = prefab.GetComponent<ZoneBlueprintSaveToolMarker>();
			if ((Object)(object)component2 != (Object)null && component2.Kind == ZoneBlueprintToolKind.Blueprint)
			{
				RegisteredPrefabs.Add(((Object)prefab).name);
				return;
			}
			CustomPiece val = new CustomPiece(prefab, "Hammer", false)
			{
				Category = "Homestead"
			};
			PieceManager.Instance.AddPiece(val);
			try
			{
				PieceManager.Instance.RegisterPieceInPieceTable(prefab, "Hammer", "Homestead");
			}
			catch
			{
			}
			RegisteredPrefabs.Add(((Object)prefab).name);
		}

		private static Sprite GetFallbackIcon()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			//IL_003a: 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_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: 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_009a: 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_00c4: 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)
			if ((Object)(object)_fallbackIcon != (Object)null)
			{
				return _fallbackIcon;
			}
			Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
			val.SetPixels((Color[])(object)new Color[4]
			{
				new Color(0.15f, 0.75f, 1f, 1f),
				new Color(0.05f, 0.2f, 0.35f, 1f),
				new Color(0.05f, 0.2f, 0.35f, 1f),
				new Color(0.15f, 0.75f, 1f, 1f)
			});
			val.Apply();
			_fallbackIcon = Sprite.Create(val, new Rect(0f, 0f, 2f, 2f), new Vector2(0.5f, 0.5f));
			return _fallbackIcon;
		}

		private static Sprite GetStoreIcon()
		{
			//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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_02d3: 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_0147: 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_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: 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_0162: 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_0177: 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_018f: 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_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_028a: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: 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_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_storeIcon != (Object)null)
			{
				return _storeIcon;
			}
			Texture2D val = new Texture2D(64, 64, (TextureFormat)4, false)
			{
				filterMode = (FilterMode)1,
				wrapMode = (TextureWrapMode)1
			};
			Color val2 = default(Color);
			((Color)(ref val2))..ctor(0f, 0f, 0f, 0f);
			Color val3 = default(Color);
			((Color)(ref val3))..ctor(0.08f, 0.11f, 0.1f, 0.95f);
			Color val4 = default(Color);
			((Color)(ref val4))..ctor(0.22f, 0.82f, 1f, 1f);
			Color val5 = default(Color);
			((Color)(ref val5))..ctor(0.22f, 0.82f, 1f, 0.34f);
			Color val6 = default(Color);
			((Color)(ref val6))..ctor(1f, 0.72f, 0.18f, 1f);
			Color val7 = default(Color);
			((Color)(ref val7))..ctor(0.62f, 0.35f, 0.14f, 1f);
			Color val8 = default(Color);
			((Color)(ref val8))..ctor(0.21f, 0.12f, 0.06f, 1f);
			Color val9 = default(Color);
			((Color)(ref val9))..ctor(0.22f, 0.78f, 1f, 1f);
			Color val10 = default(Color);
			((Color)(ref val10))..ctor(0.04f, 0.2f, 0.26f, 1f);
			Vector2 val11 = default(Vector2);
			((Vector2)(ref val11))..ctor(31.5f, 31.5f);
			for (int i = 0; i < 64; i++)
			{
				for (int num = 0; num < 64; num++)
				{
					float num2 = Vector2.Distance(new Vector2((float)num, (float)i), val11);
					Color val12 = val2;
					if (num2 <= 28f)
					{
						val12 = val3;
					}
					if (num2 >= 21f && num2 <= 25f)
					{
						val12 = val4;
					}
					else if (num2 >= 17.5f && num2 < 21f)
					{
						val12 = Color.Lerp(val12, val5, 0.65f);
					}
					bool num3 = num >= 17 && num <= 47 && i >= 18 && i <= 38;
					bool flag = num >= 20 && num <= 44 && i >= 37 && i <= 47;
					bool flag2 = (num3 || flag) && (num <= 19 || num >= 45 || i <= 20 || i >= 45 || i == 37);
					if (num3 || flag)
					{
						val12 = (flag2 ? val8 : val7);
					}
					int num4;
					int num5;
					if (num >= 25 && num <= 43 && i >= 25)
					{
						num4 = ((i <= 48) ? 1 : 0);
						if (num4 != 0)
						{
							num5 = ((num <= 27 || num >= 41 || i <= 27 || i >= 46) ? 1 : 0);
							goto IL_025a;
						}
					}
					else
					{
						num4 = 0;
					}
					num5 = 0;
					goto IL_025a;
					IL_025a:
					bool flag3 = (byte)num5 != 0;
					if (num4 != 0)
					{
						val12 = (flag3 ? val10 : val9);
					}
					if ((num - 46) * (num - 46) + (i - 18) * (i - 18) <= 36)
					{
						val12 = val6;
					}
					val.SetPixel(num, i, val12);
				}
			}
			val.Apply();
			_storeIcon = Sprite.Create(val, new Rect(0f, 0f, 64f, 64f), new Vector2(0.5f, 0.5f), 64f);
			return _storeIcon;
		}

		private static Sprite GetAreaSaveIcon()
		{
			//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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: 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_00fb: 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_0105: 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_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: 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_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: 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_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: 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_020e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_areaSaveIcon != (Object)null)
			{
				return _areaSaveIcon;
			}
			Texture2D val = new Texture2D(64, 64, (TextureFormat)4, false)
			{
				filterMode = (FilterMode)1,
				wrapMode = (TextureWrapMode)1
			};
			Color val2 = default(Color);
			((Color)(ref val2))..ctor(0f, 0f, 0f, 0f);
			Color val3 = default(Color);
			((Color)(ref val3))..ctor(0.05f, 0.12f, 0.14f, 0.95f);
			Color val4 = default(Color);
			((Color)(ref val4))..ctor(1f, 0.74f, 0.22f, 1f);
			Color val5 = default(Color);
			((Color)(ref val5))..ctor(1f, 0.74f, 0.22f, 0.34f);
			Color val6 = default(Color);
			((Color)(ref val6))..ctor(0.22f, 0.82f, 1f, 1f);
			Color val7 = default(Color);
			((Color)(ref val7))..ctor(0.04f, 0.22f, 0.28f, 1f);
			Vector2 val8 = default(Vector2);
			((Vector2)(ref val8))..ctor(31.5f, 31.5f);
			for (int i = 0; i < 64; i++)
			{
				for (int num = 0; num < 64; num++)
				{
					float num2 = Vector2.Distance(new Vector2((float)num, (float)i), val8);
					Color val9 = val2;
					if (num2 <= 28f)
					{
						val9 = val3;
					}
					if (num2 >= 21f && num2 <= 25f)
					{
						val9 = val4;
					}
					else if (num2 >= 17.5f && num2 < 21f)
					{
						val9 = Color.Lerp(val9, val5, 0.65f);
					}
					int num3;
					int num4;
					if (num >= 24 && num <= 40 && i >= 23)
					{
						num3 = ((i <= 39) ? 1 : 0);
						if (num3 != 0)
						{
							num4 = ((num <= 26 || num >= 38 || i <= 25 || i >= 37) ? 1 : 0);
							goto IL_018e;
						}
					}
					else
					{
						num3 = 0;
					}
					num4 = 0;
					goto IL_018e;
					IL_018e:
					bool flag = (byte)num4 != 0;
					if (num3 != 0)
					{
						val9 = (flag ? val6 : val7);
					}
					if ((Mathf.Abs(num - 32) <= 1 && i >= 11 && i <= 18) || (Mathf.Abs(num - 32) <= 1 && i >= 46 && i <= 53) || (Mathf.Abs(i - 32) <= 1 && num >= 11 && num <= 18) || (Mathf.Abs(i - 32) <= 1 && num >= 46 && num <= 53))
					{
						val9 = val4;
					}
					val.SetPixel(num, i, val9);
				}
			}
			val.Apply();
			_areaSaveIcon = Sprite.Create(val, new Rect(0f, 0f, 64f, 64f), new Vector2(0.5f, 0.5f), 64f);
			return _areaSaveIcon;
		}

		private static Sprite GetAreaDismantleIcon()
		{
			//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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: 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_0157: 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_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_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: Unknown result type (might be due to invalid IL or missing references)
			//IL_0289: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_areaDismantleIcon != (Object)null)
			{
				return _areaDismantleIcon;
			}
			Texture2D val = new Texture2D(64, 64, (TextureFormat)4, false)
			{
				filterMode = (FilterMode)1,
				wrapMode = (TextureWrapMode)1
			};
			Color val2 = default(Color);
			((Color)(ref val2))..ctor(0f, 0f, 0f, 0f);
			Color val3 = default(Color);
			((Color)(ref val3))..ctor(0.13f, 0.07f, 0.05f, 0.95f);
			Color val4 = default(Color);
			((Color)(ref val4))..ctor(1f, 0.31f, 0.12f, 1f);
			Color val5 = default(Color);
			((Color)(ref val5))..ctor(1f, 0.31f, 0.12f, 0.34f);
			Color val6 = default(Color);
			((Color)(ref val6))..ctor(0.86f, 0.68f, 0.42f, 1f);
			Color val7 = default(Color);
			((Color)(ref val7))..ctor(0.28f, 0.17f, 0.09f, 1f);
			Color val8 = default(Color);
			((Color)(ref val8))..ctor(1f, 0.92f, 0.7f, 1f);
			Vector2 val9 = default(Vector2);
			((Vector2)(ref val9))..ctor(31.5f, 31.5f);
			for (int i = 0; i < 64; i++)
			{
				for (int j = 0; j < 64; j++)
				{
					float num = Vector2.Distance(new Vector2((float)j, (float)i), val9);
					Color val10 = val2;
					if (num <= 28f)
					{
						val10 = val3;
					}
					if (num >= 21f && num <= 25f)
					{
						val10 = val4;
					}
					else if (num >= 17.5f && num < 21f)
					{
						val10 = Color.Lerp(val10, val5, 0.65f);
					}
					bool num2 = j >= 20 && j <= 44 && i >= 21 && i <= 29;
					bool flag = j >= 23 && j <= 47 && i >= 30 && i <= 38;
					bool flag2 = j >= 17 && j <= 41 && i >= 39 && i <= 47;
					bool flag3 = num2 || flag || flag2;
					bool flag4 = flag3;
					if (flag4)
					{
						bool flag5;
						switch (j)
						{
						case 17:
						case 20:
						case 23:
						case 41:
						case 44:
						case 47:
							flag5 = true;
							break;
						default:
							flag5 = false;
							break;
						}
						bool flag6 = flag5;
						if (!flag6)
						{
							bool flag7;
							switch (i)
							{
							case 21:
							case 29:
							case 30:
							case 38:
							case 39:
							case 47:
								flag7 = true;
								break;
							default:
								flag7 = false;
								break;
							}
							flag6 = flag7;
						}
						flag4 = flag6;
					}
					bool flag8 = flag4;
					if (flag3)
					{
						val10 = (flag8 ? val7 : val6);
					}
					if (Mathf.Abs(i - (55 - j)) <= 1 && j >= 17 && j <= 47 && i >= 17 && i <= 47)
					{
						val10 = val8;
					}
					val.SetPixel(j, i, val10);
				}
			}
			val.Apply();
			_areaDismantleIcon = Sprite.Create(val, new Rect(0f, 0f, 64f, 64f), new Vector2(0.5f, 0.5f), 64f);
			return _areaDismantleIcon;
		}

		private static string SanitizePrefabName(string name)
		{
			string text = new string(name.Select((char ch) => (!char.IsLetterOrDigit(ch) && ch != '_' && ch != '-') ? '_' : ch).ToArray());
			if (!string.IsNullOrWhiteSpace(text))
			{
				return text;
			}
			return "unnamed";
		}

		private static void TryOpenStoreListing(string blueprintName)
		{
			_storeListIntentFrame = Time.frameCount;
			_storeListIntentBlueprintName = blueprintName ?? "";
			if (Time.frameCount != _lastStoreListFrame)
			{
				_lastStoreListFrame = Time.frameCount;
				ZoneBlueprintStore.OpenSellDialog(blueprintName ?? "");
				Hud.HidePieceSelection();
			}
		}

		private static bool TryHandleStoreListingIntent(ZoneBlueprintSaveToolMarker marker)
		{
			if (marker.Kind != ZoneBlueprintToolKind.Blueprint)
			{
				return false;
			}
			if (IsStoreListClickActive())
			{
				TryOpenStoreListing(marker.BlueprintName);
				DeactivateNormalBlueprintTools();
				return true;
			}
			if (IsRecentStoreListIntent(marker.BlueprintName))
			{
				DeactivateNormalBlueprintTools();
				return true;
			}
			return false;
		}

		private static bool IsRecentStoreListIntent(string blueprintName)
		{
			if (Time.frameCount - _storeListIntentFrame <= 3)
			{
				return string.Equals(_storeListIntentBlueprintName, blueprintName ?? "", StringComparison.OrdinalIgnoreCase);
			}
			return false;
		}

		private static void DeactivateNormalBlueprintTools()
		{
			ZoneBlueprintSaveTool.Deactivate();
			ZoneAreaDismantleTool.Deactivate();
			ZoneBlueprintPlacementTool.Deactivate();
		}

		private static bool IsStoreListClickDown()
		{
			if (BlueprintConfig.IsStoreListModifierHeld())
			{
				return Input.GetMouseButtonDown(0);
			}
			return false;
		}

		private static bool IsStoreListClickActive()
		{
			if (BlueprintConfig.IsStoreListModifierHeld())
			{
				return IsPrimaryClickDownOrHeld();
			}
			return false;
		}

		private static bool IsPrimaryClickDownOrHeld()
		{
			if (!Input.GetMouseButtonDown(0) && !Input.GetMouseButton(0))
			{
				return ZInput.GetButton("Attack");
			}
			return true;
		}

		private static bool IsAnyBlueprintMenuModifierHeld()
		{
			if (!Input.GetKey((KeyCode)308) && !Input.GetKey((KeyCode)307) && !Input.GetKey((KeyCode)306) && !Input.GetKey((KeyCode)305) && !Input.GetKey((KeyCode)304) && !Input.GetKey((KeyCode)303))
			{
				return BlueprintConfig.IsStoreListModifierHeld();
			}
			return true;
		}

		private static string GetStoreListInputLabel()
		{
			string storeListModifierLabel = BlueprintConfig.StoreListModifierLabel;
			if (string.IsNullOrWhiteSpace(storeListModifierLabel) || storeListModifierLabel.Equals("None", StringComparison.OrdinalIgnoreCase))
			{
				return "Click";
			}
			return storeListModifierLabel + "+Click";
		}
	}
	internal static class ZoneBlueprintChestVfx
	{
		private readonly struct ChestVfxTransform
		{
			public Vector3 Position { get; }

			public Quaternion Rotation { get; }

			public ChestVfxTransform(Vector3 position, Quaternion rotation)
			{
				//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_0008: 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)
				Position = position;
				Rotation = rotation;
			}
		}

		internal const string ModePlan = "plan";

		private const string ModePayoutComplete = "payout_complete";

		private const string RpcName = "sighsorry.Homestead_BlueprintChestVfx";

		private const int PayloadVersion = 1;

		private const int MaxEventsPerPacket = 64;

		private const float MaxBroadcastDistance = 128f;

		private static ManualLogSource? _logger;

		private static readonly ZoneRpcRegistrar RpcRegistrar = new ZoneRpcRegistrar();

		internal static void Initialize(ManualLogSource logger)
		{
			_logger = logger;
			RegisterRpcs();
		}

		internal static void Update()
		{
			RegisterRpcs();
		}

		internal static void BroadcastPlace(string mode, ZoneBlueprintStoreTransformPayload? transform, long excludePeer)
		{
			if (transform != null)
			{
				BroadcastPlace(mode, new ZoneBlueprintStoreTransformPayload[1] { transform }, excludePeer);
			}
		}

		internal static void BroadcastPlace(string mode, IEnumerable<ZoneBlueprintStoreTransformPayload>? transforms, long excludePeer)
		{
			//IL_0055: 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 (!IsKnownMode(mode) || transforms == null || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			ZRoutedRpc instance = ZRoutedRpc.instance;
			if (instance == null)
			{
				return;
			}
			RegisterRpcs();
			List<ChestVfxTransform> list = new List<ChestVfxTransform>();
			foreach (ZoneBlueprintStoreTransformPayload transform in transforms)
			{
				if (TryReadTransform(transform, out var position, out var rotation))
				{
					list.Add(new ChestVfxTransform(position, rotation));
					if (list.Count >= 64)
					{
						SendBatch(instance, mode, list, excludePeer);
						list.Clear();
					}
				}
			}
			if (list.Count > 0)
			{
				SendBatch(instance, mode, list, excludePeer);
			}
		}

		internal static void BroadcastPayoutComplete(Vector3 position, Quaternion rotation, long excludePeer = 0L)
		{
			//IL_001c: 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_002e: 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_004c: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			BroadcastPlace("payout_complete", new ZoneBlueprintStoreTransformPayload[1]
			{
				new ZoneBlueprintStoreTransformPayload
				{
					Pos = new float[3] { position.x, position.y, position.z },
					Rot = new float[4] { rotation.x, rotation.y, rotation.z, rotation.w }
				}
			}, excludePeer);
		}

		private static void SendBatch(ZRoutedRpc routedRpc, string mode, IReadOnlyList<ChestVfxTransform> events, long excludePeer)
		{
			if (events.Count == 0 || (Object)(object)ZNet.instance == (Object)null)
			{
				return;
			}
			foreach (ZNetPeer peer in ZNet.instance.GetPeers())
			{
				if ((excludePeer == 0L || peer.m_uid != excludePeer) && ShouldSendToPeer(peer, events))
				{
					routedRpc.InvokeRoutedRPC(peer.m_uid, "sighsorry.Homestead_BlueprintChestVfx", new object[1] { CreatePackage(mode, events) });
				}
			}
		}

		private static bool ShouldSendToPeer(ZNetPeer peer, IReadOnlyList<ChestVfxTransform> events)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (peer == null || !peer.IsReady())
			{
				return false;
			}
			float num = 16384f;
			Vector3 refPos = peer.m_refPos;
			foreach (ChestVfxTransform @event in events)
			{
				Vector3 val = @event.Position - refPos;
				if (((Vector3)(ref val)).sqrMagnitude <= num)
				{
					return true;
				}
			}
			return false;
		}

		private static void RegisterRpcs()
		{
			RpcRegistrar.EnsureRegistered(delegate(ZRoutedRpc routedRpc)
			{
				routedRpc.Register<ZPackage>("sighsorry.Homestead_BlueprintChestVfx", (Action<long, ZPackage>)RPC_PlayPlaceVfx);
			});
		}

		private static void RPC_PlayPlaceVfx(long sender, ZPackage package)
		{
			//IL_0086: 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)ZNet.instance != (Object)null && ZNet.instance.IsServer())
			{
				return;
			}
			try
			{
				if (package.ReadInt() != 1)
				{
					return;
				}
				string mode = package.ReadString();
				int num = Mathf.Clamp(package.ReadInt(), 0, 64);
				if (IsKnownMode(mode))
				{
					Vector3 position = default(Vector3);
					Quaternion rotation = default(Quaternion);
					for (int i = 0; i < num; i++)
					{
						((Vector3)(ref position))..ctor(package.ReadSingle(), package.ReadSingle(), package.ReadSingle());
						((Quaternion)(ref rotation))..ctor(package.ReadSingle(), package.ReadSingle(), package.ReadSingle(), package.ReadSingle());
						PlayPlaceEffect(mode, position, rotation);
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource? logger = _logger;
				if (logger != null)
				{
					logger.LogWarning((object)("Failed to play blueprint chest world VFX: " + ex.Message));
				}
			}
		}

		private static ZPackage CreatePackage(string mode, IReadOnlyList<ChestVfxTransform> events)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: 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_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_0090: 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)
			ZPackage val = new ZPackage();
			val.Write(1);
			val.Write(mode);
			val.Write(events.Count);
			foreach (ChestVfxTransform @event in events)
			{
				val.Write(@event.Position.x);
				val.Write(@event.Position.y);
				val.Write(@event.Position.z);
				val.Write(@event.Rotation.x);
				val.Write(@event.Rotation.y);
				val.Write(@event.Rotation.z);
				val.Write(@event.Rotation.w);
			}
			return val;
		}

		private static void PlayPlaceEffect(string mode, Vector3 position, Quaternion rotation)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: 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)
			if (string.Equals(mode, "payout_complete", StringComparison.Ordinal))
			{
				ZoneBlueprintStore.PlayCompletionVfx(position);
			}
			else if (string.Equals(mode, "plan", StringComparison.Ordinal))
			{
				ZoneBlueprintPlanChestPrefab.PlayPlaceEffect(position, rotation);
			}
			else
			{
				ZoneBlueprintStoreChestPrefab.PlayPlaceEffect(mode, position, rotation);
			}
		}

		private static bool IsKnownMode(string mode)
		{
			if (!string.Equals(mode, "plan", StringComparison.Ordinal) && !string.Equals(mode, "payout_complete", StringComparison.Ordinal) && !string.Equals(mode, "price", StringComparison.Ordinal) && !string.Equals(mode, "buy", StringComparison.Ordinal))
			{
				return string.Equals(mode, "payout", StringComparison.Ordinal);
			}
			return true;
		}

		private static bool TryReadTransform(ZoneBlueprintStoreTransformPayload? payload, out Vector3 position, out Quaternion rotation)
		{
			//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)
			//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_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_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			position = Vector3.zero;
			rotation = Quaternion.identity;
			if (payload?.Pos == null || payload.Rot == null || payload.Pos.Length < 3 || payload.Rot.Length < 4)
			{
				return false;
			}
			position = new Vector3(payload.Pos[0], payload.Pos[1], payload.Pos[2]);
			rotation = new Quaternion(payload.Rot[0], payload.Rot[1], payload.Rot[2], payload.Rot[3]);
			return true;
		}
	}
	internal static class ZoneChestPlacement
	{
		public static void PlayPlaceEffect(GameObject chest)
		{
			//IL_0043: 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)
			if (!((Object)(object)ZNet.instance != (Object)null) || !ZNet.instance.IsServer() || !((Object)(object)Player.m_localPlayer == (Object)null))
			{
				Piece component = chest.GetComponent<Piece>();
				if ((Object)(object)component != (Object)null)
				{
					component.m_placeEffect.Create(chest.transform.position, chest.transform.rotation, chest.transform, 1f, -1);
				}
			}
		}

		public static bool PlayPlaceEffect(GameObject? prefab, Vector3 position, Quaternion rotation)
		{
			//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)
			Piece val = (((Object)(object)prefab != (Object)null && Object.op_Implicit((Object)(object)prefab)) ? prefab.GetComponent<Piece>() : null);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			val.m_placeEffect.Create(position, rotation, (Transform)null, 1f, -1);
			return true;
		}

		public static void SafeOnPlaced(GameObject chest, ManualLogSource? logger, string label)
		{
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer() && (Object)(object)Player.m_localPlayer == (Object)null)
			{
				return;
			}
			WearNTear component = chest.GetComponent<WearNTear>();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			try
			{
				component.OnPlaced();
			}
			catch (Exception ex)
			{
				if (logger != null)
				{
					logger.LogWarning((object)(label + " WearNTear.OnPlaced failed; continuing with Homestead chest metadata intact. This is usually caused by another mod patching WearNTear.OnPlaced. " + ex.GetType().Name + ": " + ex.Message));
				}
			}
		}

		public static void DestroySpawned(GameObject? chest)
		{
			if (Object.op_Implicit((Object)(object)chest))
			{
				ZNetView component = chest.GetComponent<ZNetView>();
				if ((Object)(object)component != (Object)null && component.IsValid())
				{
					component.Destroy();
				}
				else
				{
					Object.Destroy((Object)(object)chest);
				}
			}
		}
	}
	internal static class ZoneBlueprintChestLifecycle
	{
		internal const string OwnerPlatformIdKey = "hs_blueprint_chest_owner_platform";

		private const string CreatedUtcTicksKey = "hs_chest_created_utc_ticks";

		private const string LastTouchedUtcTicksKey = "hs_chest_touched_utc_ticks";

		public static void Initialize(ZDO? zdo)
		{
			if (zdo != null)
			{
				long ticks = DateTime.UtcNow.Ticks;
				if (zdo.GetLong("hs_chest_created_utc_ticks", 0L) <= 0)
				{
					zdo.Set("hs_chest_created_utc_ticks", ticks);
				}
				if (zdo.GetLong("hs_chest_touched_utc_ticks", 0L) <= 0)
				{
					zdo.Set("hs_chest_touched_utc_ticks", ticks);
				}
				ZoneBlueprintChestZdoRegistry.Refresh(zdo);
			}
		}

		public static void Touch(ZNetView? nview)
		{
			if (!((Object)(object)nview == (Object)null) && nview.IsValid())
			{
				ZDO zDO = nview.GetZDO();
				Initialize(zDO);
				zDO.Set("hs_chest_touched_utc_ticks", DateTime.UtcNow.Ticks);
			}
		}

		public static bool IsExpired(ZDO? zdo, int timeoutMinutes)
		{
			if (zdo == null || timeoutMinutes <= 0)
			{
				return false;
			}
			Initialize(zdo);
			long @long = zdo.GetLong("hs_chest_touched_utc_ticks", zdo.GetLong("hs_chest_created_utc_ticks", DateTime.UtcNow.Ticks));
			if (@long <= 0)
			{
				return false;
			}
			return DateTime.UtcNow - new DateTime(@long, DateTimeKind.Utc) >= TimeSpan.FromMinutes(timeoutMinutes);
		}

		public static bool CanPlaceChests(string ownerPlatformId, int requestedCount, out string reason)
		{
			reason = "";
			int maxActiveChestsPerPlayer = BlueprintConfig.MaxActiveChestsPerPlayer;
			ownerPlatformId = HomesteadPlayerIdentity.NormalizePlatformId(ownerPlatformId);
			if (maxActiveChestsPerPlayer <= 0 || string.IsNullOrWhiteSpace(ownerPlatformId) || requestedCount <= 0)
			{
				return true;
			}
			if (!ZoneBlueprintChestZdoRegistry.TryGetActiveCount(ownerPlatformId, out var count))
			{
				reason = HomesteadLocalization.Text("hs_common_world_not_ready");
				return false;
			}
			if (count + requestedCount <= maxActiveChestsPerPlayer)
			{
				return true;
			}
			reason = HomesteadLocalization.Format("hs_blueprint_chest_limit_reached", count, maxActiveChestsPerPlayer);
			return false;
		}

		public static void SetOwnerPlatformId(ZDO? zdo, string ownerPlatformId)
		{
			if (zdo != null)
			{
				zdo.Set("hs_blueprint_chest_owner_platform", HomesteadPlayerIdentity.NormalizePlatformId(ownerPlatformId));
				ZoneBlueprintChestZdoRegistry.Refresh(zdo);
			}
		}

		public static string GetOwnerPlatformId(ZDO? zdo)
		{
			return HomesteadPlayerIdentity.NormalizePlatformId(((zdo != null) ? zdo.GetString("hs_blueprint_chest_owner_platform", "") : null) ?? "");
		}
	}
	internal static class ZoneBlueprintChestMapPins
	{
		[HarmonyPatch(typeof(Minimap), "SetMapMode")]
		private static class MinimapSetMapModePatch
		{
			private static void Postfix(Minimap __instance, MapMode mode)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Invalid comparison between Unknown and I4
				if ((int)mode == 2)
				{
					_largeMapOpen = true;
					RefreshPins(__instance);
				}
				else
				{
					_largeMapOpen = false;
					ClearPins(__instance);
				}
			}
		}

		[HarmonyPatch(typeof(Minimap), "UpdatePins")]
		private static class MinimapUpdatePinsPatch
		{
			private static void Postfix()
			{
				if (_largeMapOpen && _pinsDirty)
				{
					RefreshPins(Minimap.instance);
				}
				else
				{
					ApplyPinSizes();
				}
			}
		}

		private static readonly string[] ChestPrefabNames = new string[4] { "piece_chest_wood_blueprint", "piece_chest_barrel_blueprint_store_price", "piece_chest_blueprint_store_purchase", "piece_chest_blackmetal_blueprint_store_payout" };

		private static readonly HashSet<ZDOID> KnownChestIds = new HashSet<ZDOID>();

		private static readonly List<PinData> ActivePins = new List<PinData>();

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

		private static ManualLogSource? _logger;

		private static bool _largeMapOpen;

		private static bool _pinsDirty;

		public static void Initialize(ManualLogSource logger)
		{
			_logger = logger;
		}

		public static void Shutdown()
		{
			ClearPins(Minimap.instance);
			KnownChestIds.Clear();
			_largeMapOpen = false;
			_pinsDirty = false;
		}

		public static void Track(ZDO? zdo)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if (zdo != null && zdo.IsValid() && IsChestPrefab(zdo.GetPrefab()) && KnownChestIds.Add(zdo.m_uid) && _largeMapOpen)
			{
				_pinsDirty = true;
			}
		}

		private static void RefreshPins(Minimap? minimap)
		{
			//IL_005b: 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_0066: 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_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_00d8: Unknown result type (might be due to invalid IL or missing references)
			ClearPins(minimap);
			if (BlueprintConfig.ChestMapIconSize <= 0 || (Object)(object)minimap == (Object)null || ZDOMan.instance == null || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				return;
			}
			string text = HomesteadPlayerIdentity.ResolveLocalPlatformId(Player.m_localPlayer.GetPlayerID());
			if (string.IsNullOrWhiteSpace(text))
			{
				return;
			}
			ScanKnownChests();
			List<ZDOID> list = null;
			foreach (ZDOID knownChestId in KnownChestIds)
			{
				ZDO zDO = ZDOMan.instance.GetZDO(knownChestId);
				if (zDO == null || !zDO.IsValid() || !IsChestPrefab(zDO.GetPrefab()))
				{
					if (list == null)
					{
						list = new List<ZDOID>();
					}
					list.Add(knownChestId);
				}
				else
				{
					TryAddPin(minimap, zDO, text);
				}
			}
			if (list != null)
			{
				foreach (ZDOID item in list)
				{
					KnownChestIds.Remove(item);
				}
			}
			_pinsDirty = false;
			ApplyPinSizes();
		}

		private static void ScanKnownChests()
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			if (ZDOMan.instance == null)
			{
				return;
			}
			string[] chestPrefabNames = ChestPrefabNames;
			foreach (string text in chestPrefabNames)
			{
				ScanBuffer.Clear();
				int num = 0;
				while (!ZDOMan.instance.GetAllZDOsWithPrefabIterative(text, ScanBuffer, ref num))
				{
				}
				foreach (ZDO item in ScanBuffer)
				{
					if (item != null && item.IsValid() && IsChestPrefab(item.GetPrefab()))
					{
						KnownChestIds.Add(item.m_uid);
					}
				}
			}
			ScanBuffer.Clear();
		}

		private static void TryAddPin(Minimap minimap, ZDO zdo, string ownerPlatformId)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			if (zdo != null && zdo.IsValid() && IsOwnedByPlayer(zdo, ownerPlatformId))
			{
				int prefab = zdo.GetPrefab();
				PinData val = minimap.AddPin(zdo.GetPosition(), (PinType)3, GetPinName(prefab), false, false, 0L, default(PlatformUserID));
				Sprite icon = GetIcon(prefab);
				if ((Object)(object)icon != (Object)null)
				{
					val.m_icon = icon;
				}
				ActivePins.Add(val);
			}
		}

		private static bool IsOwnedByPlayer(ZDO zdo, string ownerPlatformId)
		{
			return string.Equals(ZoneBlueprintChestLifecycle.GetOwnerPlatformId(zdo), HomesteadPlayerIdentity.NormalizePlatformId(ownerPlatformId), StringComparison.Ordinal);
		}

		private static bool IsChestPrefab(int prefabHash)
		{
			if (prefabHash != ZoneBlueprintPlanChestPrefab.PrefabHash)
			{
				return ZoneBlueprintStoreChestPrefab.IsStorePrefab(prefabHash);
			}
			return true;
		}

		private static Sprite? GetIcon(int prefabHash)
		{
			if (prefabHash == ZoneBlueprintPlanChestPrefab.PrefabHash)
			{
				return ZoneBlueprintPlanChestPrefab.GetIcon();
			}
			return ZoneBlueprintStoreChestPrefab.GetIconForPrefabHash(prefabHash);
		}

		private static string GetPinName(int prefabHash)
		{
			string text = ((prefabHash == ZoneBlueprintPlanChestPrefab.PrefabHash) ? "hs_blueprint_chest_name" : ((prefabHash == ZoneBlueprintStoreChestPrefab.PricePrefabHash) ? "hs_store_price_chest_name" : ((prefabHash == ZoneBlueprintStoreChestPrefab.PurchasePrefabHash) ? "hs_store_purchase_chest_name" : ((prefabHash != ZoneBlueprintStoreChestPrefab.PayoutPrefabHash) ? "" : "hs_store_payout_chest_name"))));
			string text2 = text;
			if (!string.IsNullOrWhiteSpace(text2))
			{
				if (Localization.instance == null)
				{
					return HomesteadLocalization.Text(text2);
				}
				return Localization.instance.Localize(HomesteadLocalization.Token(text2));
			}
			return "Homestead Chest";
		}

		private static void ClearPins(Minimap? minimap)
		{
			if ((Object)(object)minimap != (Object)null)
			{
				PinData[] array = ActivePins.ToArray();
				foreach (PinData val in array)
				{
					try
					{
						if (val != null && minimap.m_pins.Contains(val))
						{
							minimap.RemovePin(val);
						}
					}
					catch (Exception ex)
					{
						ManualLogSource? logger = _logger;
						if (logger != null)
						{
							logger.LogDebug((object)("Failed to remove blueprint chest map pin: " + ex.Message));
						}
					}
				}
			}
			ActivePins.Clear();
		}

		private static void ApplyPinSizes()
		{
			int chestMapIconSize = BlueprintConfig.ChestMapIconSize;
			if (chestMapIconSize <= 0)
			{
				return;
			}
			float num = 24f + (float)chestMapIconSize * 4.8f;
			foreach (PinData activePin in ActivePins)
			{
				if (!((Object)(object)activePin?.m_uiElement == (Object)null))
				{
					activePin.m_uiElement.SetSizeWithCurrentAnchors((Axis)0, num);
					activePin.m_uiElement.SetSizeWithCurrentAnchors((Axis)1, num);
				}
			}
		}
	}
	internal static class ZoneBlueprintChestZdoRegistry
	{
		private readonly struct Entry : IEquatable<Entry>
		{
			public ZDOID ZdoId { get; }

			public int PrefabHash { get; }

			public string OwnerPlatformId { get; }

			public Entry(ZDOID zdoId, int prefabHash, string ownerPlatformId)
			{
				//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)
				ZdoId = zdoId;
				PrefabHash = prefabHash;
				OwnerPlatformId = ownerPlatformId;
			}

			public bool Equals(Entry other)
			{
				//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)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				ZDOID zdoId = ZdoId;
				if (((ZDOID)(ref zdoId)).Equals(other.ZdoId) && PrefabHash == other.PrefabHash)
				{
					return string.Equals(OwnerPlatformId, other.OwnerPlatformId, StringComparison.Ordinal);
				}
				return false;
			}
		}

		[CompilerGenerated]
		private sealed class <EnumerateChestZdos>d__16 : IEnumerable<ZDO>, IEnumerable, IEnumerator<ZDO>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private ZDO <>2__current;

			private int <>l__initialThreadId;

			private List<ZDOID> <stale>5__2;

			private Dictionary<ZDOID, Entry>.KeyCollection.Enumerator <>7__wrap2;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<stale>5__2 = null;
				<>7__wrap2 = default(Dictionary<ZDOID, Entry>.KeyCollection.Enumerator);
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//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_0069: 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)
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						if (!CanIndex)
						{
							return false;
						}
						EnsureInitialized();
						<stale>5__2 = null;
						<>7__wrap2 = EntriesById.Keys.GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						break;
					}
					while (<>7__wrap2.MoveNext())
					{
						ZDOID current = <>7__wrap2.Current;
						ZDO zDO = ZDOMan.instance.GetZDO(current);
						if (zDO == null || !zDO.IsValid())
						{
							if (<stale>5__2 == null)
							{
								<stale>5__2 = new List<ZDOID>();
							}
							<stale>5__2.Add(current);
							continue;
						}
						<>2__current = zDO;
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>7__wrap2 = default(Dictionary<ZDOID, Entry>.KeyCollection.Enumerator);
					RemoveStale(<stale>5__2);
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

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

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

			[DebuggerHidden]
			IEnumerator<ZDO> IEnumerable<ZDO>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <EnumerateChestZdos>d__16(0);
			}

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

		private static readonly string[] ChestPrefabNames = new string[4] { "piece_chest_wood_blueprint", "piece_chest_barrel_blueprint_store_price", "piece_chest_blueprint_store_purchase", "piece_chest_blackmetal_blueprint_store_payout" };

		private static readonly Dictionary<ZDOID, Entry> EntriesById = new Dictionary<ZDOID, Entry>();

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

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

		private static ManualLogSource? _logger;

		private static ZDOMan? _trackedZdoMan;

		private static bool _initialized;

		private static bool _scanInProgress;

		private static int _scanPrefabIndex;

		private static int _scanIteratorIndex;

		private static bool CanIndex
		{
			get
			{
				if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
				{
					return ZDOMan.instance != null;
				}
				return false;
			}
		}

		public static void Initialize(ManualLogSource logger)
		{
			_logger = logger;
		}

		public static void Update()
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || ZDOMan.instance == null)
			{
				Reset();
			}
			else
			{
				EnsureInitialized();
			}
		}

		public static void Shutdown()
		{
			Reset();
		}

		public static void Refresh(ZDO? zdo)
		{
			if (CanIndex && zdo != null && zdo.IsValid())
			{
				EnsureInitialized();
				Upsert(zdo);
			}
		}

		public static bool TryGetActiveCount(string ownerPlatformId, out int count)
		{
			count = 0;
			ownerPlatformId = HomesteadPlayerIdentity.NormalizePlatformId(ownerPlatformId);
			if (string.IsNullOrWhiteSpace(ownerPlatformId) || !CanIndex)
			{
				return false;
			}
			EnsureInitialized();
			if (!_initialized)
			{
				return false;
			}
			count = (CountByOwnerPlatformId.TryGetValue(ownerPlatformId, out var value) ? value : 0);
			return true;
		}

		public static bool TryGetLiveOwnedDraftFiles(out HashSet<string> files)
		{
			//IL_0057: 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_00a2: 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)
			files = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			if (!CanIndex)
			{
				return false;
			}
			EnsureInitialized();
			List<ZDOID> list = null;
			List<Entry> list2 = null;
			foreach (KeyValuePair<ZDOID, Entry> item in EntriesById)
			{
				if (item.Value.PrefabHash != ZoneBlueprintStoreChestPrefab.PricePrefabHash)
				{
					continue;
				}
				ZDO zDO = ZDOMan.instance.GetZDO(item.Key);
				if (zDO == null || !zDO.IsValid())
				{
					if (list == null)
					{
						list = new List<ZDOID>();
					}
					list.Add(item.Key);
					continue;
				}
				if (!TryBuildEntry(zDO, out var entry))
				{
					if (list == null)
					{
						list = new List<ZDOID>();
					}
					list.Add(item.Key);
					continue;
				}
				if (!entry.Equals(item.Value))
				{
					if (list2 == null)
					{
						list2 = new List<Entry>();
					}
					list2.Add(entry);
				}
				if (string.Equals(zDO.GetString("hs_store_mode", ""), "price", StringComparison.Ordinal) && !zDO.GetBool("hs_store_confirmed", false) && zDO.GetBool("hs_store_draft_owned_by_chest", false))
				{
					string fileName = Path.GetFileName(zDO.GetString("hs_store_blueprint_file", ""));
					if (!string.IsNullOrWhiteSpace(fileName))
					{
						files.Add(fileName);
					}
				}
			}
			RemoveStale(list);
			if (list2 != null)
			{
				foreach (Entry item2 in list2)
				{
					if (EntriesById.TryGetValue(item2.ZdoId, out var value))
					{
						Replace(value, item2);
					}
				}
			}
			return true;
		}

		[IteratorStateMachine(typeof(<EnumerateChestZdos>d__16))]
		public static IEnumerable<ZDO> EnumerateChestZdos()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <EnumerateChestZdos>d__16(-2);
		}

		private static void EnsureInitialized()
		{
			if (!CanIndex)
			{
				return;
			}
			if (_trackedZdoMan != ZDOMan.instance)
			{
				UnhookDestroyed();
				_trackedZdoMan = ZDOMan.instance;
				_trackedZdoMan.m_onZDODestroyed = (Action<ZDO>)Delegate.Combine(_trackedZdoMan.m_onZDODestroyed, new Action<ZDO>(HandleZdoDestroyed));
				_initialized = false;
				_scanInProgress = false;
				_scanPrefabIndex = 0;
				_scanIteratorIndex = 0;
				PrefabScanBuffer.Clear();
			}
			if (!_initialized)
			{
				if (!_scanInProgress)
				{
					EntriesById.Clear();
					CountByOwnerPlatformId.Clear();
					PrefabScanBuffer.Clear();
					_scanPrefabIndex = 0;
					_scanIteratorIndex = 0;
					_scanInProgress = true;
				}
				ContinuePrefabScan();
			}
		}

		private static void ContinuePrefabScan()
		{
			if (ZDOMan.instance == null || !_scanInProgress)
			{
				return;
			}
			if (_scanPrefabIndex >= ChestPrefabNames.Length)
			{
				CompletePrefabScan();
				return;
			}
			string text = ChestPrefabNames[_scanPrefabIndex];
			if (!ZDOMan.instance.GetAllZDOsWithPrefabIterative(text, PrefabScanBuffer, ref _scanIteratorIndex))
			{
				return;
			}
			foreach (ZDO item in PrefabScanBuffer)
			{
				Upsert(item);
			}
			PrefabScanBuffer.Clear();
			_scanPrefabIndex++;
			_scanIteratorIndex = 0;
			if (_scanPrefabIndex >= ChestPrefabNames.Length)
			{
				CompletePrefabScan();
			}
		}

		private static void CompletePrefabScan()
		{
			PrefabScanBuffer.Clear();
			_scanInProgress = false;
			_initialized = true;
			ManualLogSource? logger = _logger;
			if (logger != null)
			{
				logger.LogDebug((object)$"Blueprint chest ZDO registry initialized with {EntriesById.Count} chest(s).");
			}
		}

		private static void Upsert(ZDO zdo)
		{
			//IL_001d: 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_003a: Unknown result type (might be due to invalid IL or missing references)
			if (!TryBuildEntry(zdo, out var entry))
			{
				Remove(zdo.m_uid);
				return;
			}
			if (EntriesById.TryGetValue(entry.ZdoId, out var value))
			{
				Replace(value, entry);
				return;
			}
			EntriesById[entry.ZdoId] = entry;
			AddCounts(entry);
		}

		private static void Replace(Entry existing, Entry current)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			RemoveCounts(existing);
			EntriesById[current.ZdoId] = current;
			AddCounts(current);
		}

		private static void Remove(ZDOID id)
		{
			//IL_0005: 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 (EntriesById.TryGetValue(id, out var value))
			{
				EntriesById.Remove(id);
				RemoveCounts(value);
			}
		}

		private static void RemoveStale(List<ZDOID>? stale)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (stale == null)
			{
				return;
			}
			foreach (ZDOID item in stale)
			{
				Remove(item);
			}
		}

		private static bool TryBuildEntry(ZDO zdo, out Entry entry)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			entry = default(Entry);
			if (zdo == null || !zdo.IsValid())
			{
				return false;
			}
			int prefab = zdo.GetPrefab();
			if (!IsChestPrefab(prefab))
			{
				return false;
			}
			string ownerPlatformId = ZoneBlueprintChestLifecycle.GetOwnerPlatformId(zdo);
			if (string.IsNullOrWhiteSpace(ownerPlatformId))
			{
				return false;
			}
			entry = new Entry(zdo.m_uid, prefab, ownerPlatformId);
			return true;
		}

		private static bool IsChestPrefab(int prefabHash)
		{
			if (prefabHash != ZoneBlueprintPlanChestPrefab.PrefabHash)
			{
				return ZoneBlueprintStoreChestPrefab.IsStorePrefab(prefabHash);
			}
			return true;
		}

		private static void AddCounts(Entry entry)
		{
			CountByOwnerPlatformId[entry.OwnerPlatformId] = ((!CountByOwnerPlatformId.TryGetValue(entry.OwnerPlatformId, out var value)) ? 1 : (value + 1));
		}

		private static void RemoveCounts(Entry entry)
		{
			if (CountByOwnerPlatformId.TryGetValue(entry.OwnerPlatformId, out var value))
			{
				if (value <= 1)
				{
					CountByOwnerPlatformId.Remove(entry.OwnerPlatformId);
				}
				else
				{
					CountByOwnerPlatformId[entry.OwnerPlatformId] = value - 1;
				}
			}
		}

		private static void HandleZdoDestroyed(ZDO zdo)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			if (zdo != null)
			{
				Remove(zdo.m_uid);
			}
		}

		private static void Reset()
		{
			UnhookDestroyed();
			EntriesById.Clear();
			CountByOwnerPlatformId.Clear();
			PrefabScanBuffer.Clear();
			_initialized = false;
			_scanInProgress = false;
			_scanPrefabIndex = 0;
			_scanIteratorIndex = 0;
		}

		private static void UnhookDestroyed()
		{
			if (_trackedZdoMan != null)
			{
				_trackedZdoMan.m_onZDODestroyed = (Action<ZDO>)Delegate.Remove(_trackedZdoMan.m_onZDODestroyed, new Action<ZDO>(HandleZdoDestroyed));
				_trackedZdoMan = null;
			}
		}
	}
	[HarmonyPatch(typeof(ZNetScene), "CreateObject", new Type[] { typeof(ZDO) })]
	internal static class ZoneBlueprintChestZNetSceneCreateObjectPatch
	{
		private static void Postfix(ZDO zdo)
		{
			ZoneBlueprintChestZdoRegistry.Refresh(zdo);
			ZoneBlueprintChestMapPins.Track(zdo);
		}
	}
	internal static class ZoneBlueprintStore
	{
		private static class ZoneBlueprintStoreRequestDispatcher
		{
			public static ZoneBlueprintStoreRpcEnvelope Execute(ZoneBlueprintStoreRpcEnvelope envelope, Player? player, long sender)
			{
				return envelope.Type switch
				{
					"list" => ZoneBlueprintStoreListAction.Execute(ReadPayload<ZoneBlueprintStoreListRequest>(envelope), player, sender), 
					"price_chest" => ZoneBlueprintStoreListingAction.ExecutePriceChest(ReadPayload<ZoneBlueprintStorePriceChestRequest>(envelope), player, sender), 
					"publish" => ZoneBlueprintStoreListingAction.ExecutePublish(ReadPayload<ZoneBlueprintStorePublishRequest>(envelope), player, sender), 
					"preview" => ZoneBlueprintStorePreviewAction.ExecutePreview(ReadPayload<ZoneBlueprintStorePreviewRequest>(envelope)), 
					"preview_restore" => ZoneBlueprintStorePreviewAction.ExecutePreviewRestore(ReadPayload<ZoneBlueprintStorePreviewRestoreRequest>(envelope), player, sender), 
					"buy" => ZoneBlueprintStorePurchaseAction.ExecuteBuy(ReadPayload<ZoneBlueprintStoreBuyRequest>(envelope), player, sender), 
					"confirm" => ZoneBlueprintStorePurchaseAction.ExecuteConfirmResponse(ReadPayload<ZoneBlueprintStoreConfirmPurchaseRequest>(envelope), player, sender), 
					"confirm_listing" => ZoneBlueprintStoreListingAction.ExecuteConfirmListingResponse(ReadPayload<ZoneBlueprintStoreConfirmListingRequest>(envelope), player, sender), 
					"delist" => ZoneBlueprintStoreListingAction.ExecuteDelist(ReadPayload<ZoneBlueprintStoreDelistRequest>(envelope), player, sender), 
					"edit_price" => ZoneBlueprintStoreListingAction.ExecuteEditPrice(ReadPayload<ZoneBlueprintStoreEditPriceRequest>(envelope), player, sender), 
					"create_offer" => ZoneBlueprintStoreOfferAction.ExecuteCreate(ReadPayload<ZoneBlueprintStoreCreateOfferRequest>(envelope), player, sender), 
					"list_offers" => ZoneBlueprintStoreOfferAction.ExecuteList(ReadPayload<ZoneBlueprintStoreListOffersRequest>(envelope), player, sender), 
					"decide_offer" => ZoneBlueprintStoreOfferAction.ExecuteDecision(ReadPayload<ZoneBlueprintStoreDecideOfferRequest>(envelope), player, sender), 
					"delete_offer" => ZoneBlueprintStoreOfferAction.ExecuteDelete(ReadPayload<ZoneBlueprintStoreDeleteOfferRequest>(envelope), player, sender), 
					"get_notifications" => ZoneBlueprintStoreNotificationAction.ExecuteGet(player, sender), 
					"recent_notifications" => ZoneBlueprintStoreNotificationAction.ExecuteRecent(ReadPayload<ZoneBlueprintStoreRecentNotificationsRequest>(envelope), player, sender), 
					"read_notifications" => ZoneBlueprintStoreNotificationAction.ExecuteRead(ReadPayload<ZoneBlueprintStoreReadNotificationsRequest>(envelope), player, sender), 
					"sync_hidden" => ZoneBlueprintStoreHiddenStateAction.Execute(ReadPayload<ZoneBlueprintStoreSyncHiddenRequest>(envelope), player, sender), 
					"withdraw" => ZoneBlueprintStoreWithdrawAction.Execute(ReadPayload<ZoneBlueprintStoreWithdrawRequest>(envelope), player, sender), 
					_ => Fail(envelope.Type, "Unknown blueprint store action '" + envelope.Type + "'."), 
				};
			}
		}

		private static class ZoneBlueprintStoreChestLookup
		{
			public static ZoneBlueprintStoreChest? FindPurchaseChest(string listingId, ZoneBlueprintStoreActor buyer, string offerId = "")
			{
				return ZoneBlueprintStoreChestRegistry.FindPurchaseChest(listingId, buyer, offerId);
			}

			public static ZoneBlueprintStoreChest? FindPriceChest(string listingId, ZoneBlueprintStoreActor seller)
			{
				return ZoneBlueprintStoreChestRegistry.FindPriceChest(listingId, seller);
			}
		}

		private static class ZoneBlueprintStoreListAction
		{
			public static ZoneBlueprintStoreRpcEnvelope Execute(ZoneBlueprintStoreListRequest request, Player? player, long sender)
			{
				ZoneBlueprintStoreListRequest request2 = request;
				long playerId = 0L;
				string platformId = "";
				if (TryResolveRequester(player, sender, out long playerId2, out string _, out Vector3 _, out Quaternion _, out string _))
				{
					playerId = playerId2;
					platformId = ResolveRequesterPlatformId(player, sender, playerId);
				}
				ZoneBlueprintStoreCatalog catalog = ZoneBlueprintStoreDraftRepository.LoadCatalogReadOnly();
				ZoneBlueprintStoreDraftRepository.DeactivateExpiredListings(catalog);
				if (request2.IconsOnly)
				{
					return CreateEnvelope("list", BuildIconOnlyResponse(request2, catalog));
				}
				HashSet<string> hiddenListingIds = GetHiddenListingIds(playerId, platformId);
				List<ZoneBlueprintStoreListing> list = catalog.Listings.Where((ZoneBlueprintStoreListing listing) => listing.Active).OrderByDescending<ZoneBlueprintStoreListing, string>((ZoneBlueprintStoreListing listing) => listing.CreatedAt, StringComparer.Ordinal).ToList();
				int hiddenListings = list.Count((ZoneBlueprintStoreListing listing) => hiddenListingIds.Contains(listing.ListingId));
				List<ZoneBlueprintStoreListing> list2 = (request2.ShowHidden ? list : list.Where((ZoneBlueprintStoreListing listing) => !hiddenListingIds.Contains(listing.ListingId)).ToList());
				int count = list2.Count;
				int num = Mathf.Clamp(request2.Offset, 0, Math.Max(0, count));
				int num2 = Mathf.Clamp(request2.Limit, 0, 50);
				if (num2 > 0 && count > 0)
				{
					num = Math.Min(num, (count - 1) / num2 * num2);
				}
				List<ZoneBlueprintStoreListing> list3 = ((num2 > 0) ? list2.Skip(num).Take(num2).ToList() : list2);
				Dictionary<string, int> offerCounts = BuildOfferCounts(catalog);
				HashSet<string> listIconListingIds = GetListIconListingIds(request2, list3);
				int value;
				return CreateEnvelope("list", new ZoneBlueprintStoreListResponse
				{
					Success = true,
					RequestId = request2.RequestId,
					TotalListings = count,
					Offset = num,
					Limit = num2,
					HiddenListings = hiddenListings,
					HasMore = (num2 > 0 && num + list3.Count < count),
					HasWithdrawableBalance = HasWithdrawableBalance(catalog, playerId, platformId),
					Listings = list3.Select((ZoneBlueprintStoreListing listing) => ToSummaryDto(listing, playerId, platformId, catalog, offerCounts.TryGetValue(listing.ListingId, out value) ? value : 0, request2.IncludeDebugIdentity)).ToList(),
					Icons = BuildListingIconDtos(list3, listIconListingIds),
					Notifications = (request2.IncludeNotifications ? GetUnreadNotifications(catalog, playerId, platformId) : new List<ZoneBlueprintStoreNotificationDto>())
				});
			}

			private static ZoneBlueprintStoreListResponse BuildIconOnlyResponse(ZoneBlueprintStoreListRequest request, ZoneBlueprintStoreCatalog catalog)
			{
				HashSet<string> requestedIconListingIds = GetRequestedIconListingIds(request.IconListingIds, 6);
				if (requestedIconListingIds.Count == 0)
				{
					return new ZoneBlueprintStoreListResponse
					{
						Success = true,
						RequestId = request.RequestId,
						IconsOnly = true
					};
				}
				return new ZoneBlueprintStoreListResponse
				{
					Success = true,
					RequestId = request.RequestId,
					IconsOnly = true,
					Icons = BuildListingIconDtos(catalog.Listings.Where((ZoneBlueprintStoreListing listing) => listing.Active), requestedIconListingIds)
				};
			}

			private static HashSet<string> GetListIconListingIds(ZoneBlueprintStoreListRequest request, IReadOnlyList<ZoneBlueprintStoreListing> activeListings)
			{
				HashSet<string> requestedIconListingIds = GetRequestedIconListingIds(request.IconListingIds, 6);
				if (requestedIconListingIds.Count > 0)
				{
					return requestedIconListingIds;
				}
				int num = Mathf.Clamp(request.FirstIconCount, 0, 6);
				for (int i = 0; i < num && i < activeListings.Count; i++)
				{
					requestedIconListingIds.Add(activeListings[i].ListingId);
				}
				return requestedIconListingIds;
			}

			private static HashSet<string> GetRequestedIconListingIds(IEnumerable<string>? listingIds, int maxCount)
			{
				HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
				maxCount = Mathf.Clamp(maxCount, 0, 50);
				if (listingIds == null || maxCount <= 0)
				{
					return hashSet;
				}
				foreach (string listingId in listingIds)
				{
					if (!string.IsNullOrWhiteSpace(listingId))
					{
						hashSet.Add(listingId);
						if (hashSet.Count >= maxCount)
						{
							break;
						}
					}
				}
				return hashSet;
			}

			private static List<ZoneBlueprintStoreListingIconDto> BuildListingIconDtos(IEnumerable<ZoneBlueprintStoreListing> listings, ISet<string> iconListingIds)
			{
				ISet<string> iconListingIds2 = iconListingIds;
				return (from listing in listings
					where iconListingIds2.Contains(listing.ListingId) && ZoneBlueprintNetworkPayload.ShouldSendIconBase64(listing.IconPngBase64)
					select new ZoneBlueprintStoreListingIconDto
					{
						ListingId = listing.ListingId,
						IconPngBase64 = listing.IconPngBase64
					}).ToList();
			}
		}

		private static class ZoneBlueprintStoreHiddenStateAction
		{
			public static ZoneBlueprintStoreRpcEnvelope Execute(ZoneBlueprintStoreSyncHiddenRequest request, Player? player, long sender)
			{
				if (!TryResolveRequester(player, sender, out long playerId, out string _, out Vector3 _, out Quaternion _, out string reason))
				{
					return Fail("sync_hidden", reason);
				}
				string platformId = ResolveRequesterPlatformId(player, sender, playerId);
				SetHiddenListingIds(playerId, platformId, request.HiddenListingIds);
				return Status("sync_hidden", success: true, "");
			}
		}

		private static class ZoneBlueprintStoreListingAction
		{
			private static string GetListingExpiryAt(DateTime utcNow)
			{
				int listingDays = BlueprintConfig.StoreSettings.ListingDays;
				if (listingDays > 0)
				{
					return HomesteadTimestamp.Format(utcNow.AddDays(listingDays));
				}
				return "";
			}

			public static ZoneBlueprintStoreRpcEnvelope ExecutePriceChest(ZoneBlueprintStorePriceChestRequest request, Player? player, long sender)
			{
				//IL_0100: 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_0104: Unknown result type (might be due to invalid IL or missing references)
				//IL_0105: Unknown result type (might be due to invalid IL or missing references)
				//IL_0107: Unknown result type (might be due to invalid IL or missing references)
				//IL_0109: Unknown result type (might be due to invalid IL or missing references)
				//IL_0116: 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_014f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0150: 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_0166: Unknown result type (might be due to invalid IL or missing references)
				//IL_016b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0170: Unknown result type (might be due to invalid IL or missing references)
				//IL_0174: 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_0182: 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_0141: 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_0145: Unknown result type (might be due to invalid IL or missing references)
				//IL_0147: 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_014b: Unknown result type (might be due to invalid IL or missing references)
				//IL_019e: Unknown result type (might be due to invalid IL or missing references)
				//IL_019f: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a1: 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_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_01e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_0243: 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)
				ZoneBlueprintStorePriceChestRequest request2 = request;
				if (!TryResolveRequester(player, sender, out long playerId, out string playerName, out Vector3 position, out Quaternion rotation, out string reason))
				{
					return FailPrice(reason);
				}
				string sellerPlatformId = ResolveRequesterPlatformId(player, sender, playerId);
				ZoneBlueprintStoreCatalog catalog = ZoneBlueprintStoreDraftRepository.LoadCatalogReadOnly();
				ZoneBlueprintStoreDraftRepository.DeactivateExpiredListings(catalog);
				if (!CheckStoreListingLimit(catalog, playerId, sellerPlatformId, out string reason2))
				{
					return FailPrice(reason2);
				}
				string text = ZoneBlueprintStoreDraftRepository.TrimName(request2.Name);
				if (string.IsNullOrWhiteSpace(text))
				{
					return FailPrice(HomesteadLocalization.Text("hs_store_blueprint_name_required"));
				}
				if (!ZoneBlueprintNetworkPayload.TryValidateIconBase64(request2.IconPngBase64, out string reason3))
				{
					return FailPrice(reason3);
				}
				if (!ZoneBlueprintNetworkPayload.TryDeserializeBlueprintUpload(request2.BlueprintPayload, request2.BlueprintEncoding, out ZoneBlueprintFile blueprint, out string reason4))
				{
					return FailPrice(reason4);
				}
				string text2 = ValidateStoreBlueprint(blueprint);
				if (!string.IsNullOrWhiteSpace(text2))
				{
					return FailPrice(text2);
				}
				ZoneBlueprintStoreDraftLease zoneBlueprintStoreDraftLease = ZoneBlueprintStoreDraftRepository.CreateDraft(text, blueprint);
				string listingId = zoneBlueprintStoreDraftLease.ListingId;
				string blueprintFile = zoneBlueprintStoreDraftLease.BlueprintFile;
				Quaternion rotation2 = rotation;
				Vector3 position2 = position;
				Quaternion rotation3 = rotation;
				if (!TryReadOptionalStoreChestTarget(request2.Target, position, rotation, out bool hasTarget, out Vector3 position3, out Quaternion rotation4, out reason))
				{
					ZoneBlueprintStoreDraftRepository.DeleteFile(blueprintFile);
					return FailPrice(reason);
				}
				Vector3 val;
				if (hasTarget)
				{
					val = position3;
					rotation2 = rotation4;
					position2 = position3;
					rotation3 = rotation4;
				}
				else
				{
					val = position + rotation * new Vector3(0f, 0f, 2.2f);
					val.y = SampleGroundY(val.x, val.z, val.y);
				}
				if (!TryReadOptionalStorePreviewAnchor(request2.PreviewAnchor, position, position2, rotation3, out position2, out rotation3, out reason))
				{
					ZoneBlueprintStoreDraftRepository.DeleteFile(blueprintFile);
					return FailPrice(reason);
				}
				HomesteadCommandResult homesteadCommandResult = ZoneBlueprintStoreChestPrefab.PlacePriceChest(listingId, text, blueprintFile, request2.IconPngBase64, blueprint.Entries.Count, playerId, playerName, sellerPlatformId, val, rotation2, position2, rotation3, sender);
				if (!homesteadCommandResult.Success)
				{
					ZoneBlueprintStoreDraftRepository.DeleteFile(blueprintFile);
				}
				return CreateEnvelope("price_chest", new ZoneBlueprintStorePriceChestResponse
				{
					Success = homesteadCommandResult.Success,
					Message = homesteadCommandResult.Message,
					ListingId = listingId,
					Name = text,
					Chest = (homesteadCommandResult.Success ? ToTransformPayload(val, rotation2) : null)
				});
				ZoneBlueprintStoreRpcEnvelope FailPrice(string message)
				{
					return CreateEnvelope("price_chest", new ZoneBlueprintStorePriceChestResponse
					{
						Success = false,
						Message = message,
						Name = request2.Name
					});
				}
			}

			public static ZoneBlueprintStoreRpcEnvelope ExecutePublish(ZoneBlueprintStorePublishRequest request, Player? player, long sender)
			{
				if (!TryResolveRequester(player, sender, out long playerId, out string playerName, out Vector3 _, out Quaternion _, out string reason))
				{
					return Fail("publish", reason);
				}
				string sellerPlatformId = ResolveRequesterPlatformId(player, sender, playerId);
				string text = ZoneBlueprintStoreDraftRepository.TrimName(request.Name);
				if (string.IsNullOrWhiteSpace(text))
				{
					return Fail("publish", HomesteadLocalization.Text("hs_store_blueprint_name_required"));
				}
				List<ZoneBlueprintStorePriceItem> priceItems = NormalizePriceItems(request.PriceItems);
				if (priceItems.Count == 0)
				{
					return Fail("publish", HomesteadLocalization.Text("hs_store_price_required"));
				}
				if (priceItems.Count > 8)
				{
					return Fail("publish", HomesteadLocalization.Format("hs_store_price_too_many_types", 8));
				}
				if (!TryValidatePriceItems(priceItems, out priceItems, out string reason2))
				{
					return Fail("publish", reason2);
				}
				ZoneBlueprintStoreCatalog zoneBlueprintStoreCatalog = ZoneBlueprintStoreDraftRepository.LoadCatalog();
				ZoneBlueprintStoreDraftRepository.DeactivateExpiredListings(zoneBlueprintStoreCatalog);
				if (!CheckStoreListingLimit(zoneBlueprintStoreCatalog, playerId, sellerPlatformId, out string reason3))
				{
					return Fail("publish", reason3);
				}
				if (!ZoneBlueprintNetworkPayload.TryValidateIconBase64(request.IconPngBase64, out string reason4))
				{
					return Fail("publish", reason4);
				}
				if (!ZoneBlueprintNetworkPayload.TryDeserializeBlueprintUpload(request.BlueprintPayload, request.BlueprintEncoding, out ZoneBlueprintFile blueprint, out string reason5))
				{
					return Fail("publish", reason5);
				}
				string text2 = ValidateStoreBlueprint(blueprint);
				if (!string.IsNullOrWhiteSpace(text2))
				{
					return Fail("publish", text2);
				}
				ZoneBlueprintStoreDraftLease zoneBlueprintStoreDraftLease = ZoneBlueprintStoreDraftRepository.CreateDraft(text, blueprint);
				string listingId = zoneBlueprintStoreDraftLease.ListingId;
				string blueprintFile = zoneBlueprintStoreDraftLease.BlueprintFile;
				DateTime utcNow = DateTime.UtcNow;
				ZoneBlueprintStoreListing zoneBlueprintStoreListing = new ZoneBlueprintStoreListing
				{
					ListingId = listingId,
					Name = text,
					SellerName = playerName,
					SellerPlayerId = playerId,
					SellerPlatformId = sellerPlatformId,
					CreatedAt = HomesteadTimestamp.Format(utcNow),
					ExpiresAt = GetListingExpiryAt(utcNow),
					PriceItems = priceItems,
					EntryCount = blueprint.Entries.Count,
					BlueprintFile = blueprintFile,
					IconPngBase64 = request.IconPngBase64,
					Active = true
				};
				zoneBlueprintStoreCatalog.Listings.Add(zoneBlueprintStoreListing);
				AddPublicNewListingNotification(zoneBlueprintStoreCatalog, playerName, zoneBlueprintStoreListing);
				ZoneBlueprintStoreDraftRepository.SaveCatalog(zoneBlueprintStoreCatalog, immediate: true);
				PushLatestNotification(zoneBlueprintStoreCatalog);
				return Status("publish", success: true, HomesteadLocalization.Format("hs_store_listed", text, FormatPrice(priceItems)));
			}

			public static ZoneBlueprintStoreRpcEnvelope ExecuteConfirmListingResponse(ZoneBlueprintStoreConfirmListingRequest request, Player? player, long sender)
			{
				if (!TryResolveRequester(player, sender, out long playerId, out string _, out Vector3 _, out Quaternion _, out string reason))
				{
					return CreateEnvelope("confirm_listing", new ZoneBlueprintStoreConfirmListingResponse
					{
						Success = false,
						Message = reason,
						ListingId = request.ListingId
					});
				}
				HomesteadCommandResult homesteadCommandResult = ExecuteConfirmListing(request.ListingId, ResolveRequesterActor(player, sender, playerId), sender, null, request.PriceItems);
				return CreateEnvelope("confirm_listing", new ZoneBlueprintStoreConfirmListingResponse
				{
					Success = homesteadCommandResult.Success,
					Message = homesteadCommandResult.Message,
					ListingId = request.ListingId
				});
			}

			public static HomesteadCommandResult ExecuteConfirmListing(string listingId, ZoneBlueprintStoreActor seller, long targetPeer, ZoneBlueprintStoreChest? directChest, IReadOnlyList<ZoneBlueprintStorePriceItem>? overridePriceItems = null)
			{
				string listingId2 = listingId;
				ZoneBlueprintStoreChest zoneBlueprintStoreChest = directChest ?? FindPriceChest(listingId2, seller);
				ZDO zdo = null;
				if ((Object)(object)zoneBlueprintStoreChest == (Object)null && !ZoneBlueprintStoreChestRegistry.TryFindPriceChestZdo(listingId2, seller, out zdo))
				{
					return HomesteadCommandResult.Fail(HomesteadLocalization.Text("hs_store_listing_chest_missing_nearby"));
				}
				if (!(((Object)(object)zoneBlueprintStoreChest != (Object)null) ? zoneBlueprintStoreChest.TryReadListingDraft(out string name, out string sellerName, out string blueprintFile, out int entryCount, out string reason) : ZoneBlueprintStoreChest.TryReadListingDraft(zdo, out name, out sellerName, out blueprintFile, out entryCount, out reason)))
				{
					return HomesteadCommandResult.Fail(reason);
				}
				List<ZoneBlueprintStorePriceItem> priceItems = ((overridePriceItems != null && overridePriceItems.Count > 0) ? NormalizePriceItems(overridePriceItems) : (((Object)(object)zoneBlueprintStoreChest != (Object)null) ? zoneBlueprintStoreChest.ReadPriceItems() : new List<ZoneBlueprintStorePriceItem>()));
				if (priceItems.Count == 0)
				{
					return HomesteadCommandResult.Fail(HomesteadLocalization.Text("hs_store_price_required"));
				}
				if (!TryValidatePriceItems(priceItems, out priceItems, out string reason2))
				{
					return HomesteadCommandResult.Fail(reason2);
				}
				if (!ZoneBlueprintStoreDraftRepository.TryLoadBlueprintFile(blueprintFile, out ZoneBlueprintFile _, out string _))
				{
					return HomesteadCommandResult.Fail(HomesteadLocalization.Text("hs_store_draft_file_missing"));
				}
				ZoneBlueprintStoreCatalog zoneBlueprintStoreCatalog = ZoneBlueprintStoreDraftRepository.LoadCatalog();
				ZoneBlueprintStoreDraftRepository.DeactivateExpiredListings(zoneBlueprintStoreCatalog);
				if (zoneBlueprintStoreCatalog.Listings.Any((ZoneBlueprintStoreListing item) => item.ListingId == listingId2))
				{
					return HomesteadCommandResult.Fail(HomesteadLocalization.Text("hs_store_already_listed"));
				}
				string platformId = seller.PlatformId;
				if (!CheckStoreListingLimit(zoneBlueprintStoreCatalog, seller.PlayerId, platformId, out string reason4))
				{
					return HomesteadCommandResult.Fail(reason4);
				}
				DateTime utcNow = DateTime.UtcNow;
				ZoneBlueprintStoreListing zoneBlueprintStoreListing = new ZoneBlueprintStoreListing
				{
					ListingId = listingId2,
					Name = name,
					SellerName = sellerName,
					SellerPlayerId = seller.PlayerId,
					SellerPlatformId = platformId,
					CreatedAt = HomesteadTimestamp.Format(utcNow),
					ExpiresAt = GetListingExpiryAt(utcNow),
					PriceItems = priceItems,
					EntryCount = entryCount,
					BlueprintFile = blueprintFile,
					IconPngBase64 = (((Object)(object)zoneBlueprintStoreChest != (Object)null) ? zoneBlueprintStoreChest.GetIconPngBase64() : ZoneBlueprintStoreChest.GetIconPngBase64(zdo)),
					Active = true
				};
				zoneBlueprintStoreCatalog.Listings.Add(zoneBlueprintStoreListing);
				AddPublicNewListingNotification(zoneBlueprintStoreCatalog, sellerName, zoneBlueprintStoreListing);
				ZoneBlueprintStoreDraftRepository.SaveCatalog(zoneBlueprintStoreCatalog, immediate: true);
				PushLatestNotification(zoneBlueprintStoreCatalog);
				if ((Object)(object)zoneBlueprintStoreChest != (Object)null)
				{
					zoneBlueprintStoreChest.ReleaseDraftFileOwnership();
					zoneBlueprintStoreChest.DropAllContents();
					zoneBlueprintStoreChest.MarkConfirmed();
					zoneBlueprintStoreChest.DestroyChest();
				}
				else
				{
					ZoneBlueprintStoreChest.MarkConfirmed(zdo);
					if (zdo != null)
					{
						SavedZdoHelper.Destroy(zdo);
						SavedZdoHelper.FlushDestroyed();
					}
				}
				string message = HomesteadLocalization.Format("hs_store_listed", name, FormatPrice(priceItems));
				if (targetPeer == 0L)
				{
					Message(message, (MessageType)1);
				}
				return HomesteadCommandResult.Ok(message);
			}

			public static ZoneBlueprintStoreRpcEnvelope ExecuteDelist(ZoneBlueprintStoreDelistRequest request, Player? player, long sender)
			{
				ZoneBlueprintStoreDelistRequest request2 = request;
				if (!TryResolveRequester(player, sender, out long playerId, out string _, out Vector3 _, out Quaternion _, out string reason))
				{
					return Fail("delist", reason);
				}
				string platformId = ResolveRequesterPlatformId(player, sender, playerId);
				ZoneBlueprintStoreCatalog zoneBlueprintStoreCatalog = ZoneBlueprintStoreDraftRepository.LoadCatalog();
				ZoneBlueprintStoreDraftRepository.DeactivateExpiredListings(zoneBlueprintStoreCatalog);
				ZoneBlueprintStoreListing zoneBlueprintStoreListing = zoneBlueprintStoreCatalog.Listings.FirstOrDefault((ZoneBlueprintStoreListing item) => item.Active && string.Equals(item.ListingId, request2.ListingId, StringComparison.Ordinal));
				if (zoneBlueprintStoreListing == null)
				{
					return Fail("delist", HomesteadLocalization.Text("hs_store_listing_not_found"));
				}
				if (!IsStoreListingOwner(zoneBlueprintStoreListing, playerId, platformId))
				{
					return Fail("delist", HomesteadLocalization.Text("hs_store_only_seller_delist"));
				}
				zoneBlueprintStoreListing.Active = false;
				ZoneBlueprintStoreDraftRepository.SaveCatalog(zoneBlueprintStoreCatalog);
				return StatusWithListingPatch("delist", success: true, HomesteadLocalization.Format("hs_store_delisted", zoneBlueprintStoreListing.Name), zoneBlueprintStoreCatalog, zoneBlueprintStoreListing, playerId, platformId, removeListing: true);
			}

			public static ZoneBlueprintStoreRpcEnvelope ExecuteEditPrice(ZoneBlueprintStoreEditPriceRequest request, Player? player, long sender)
			{
				ZoneBlueprintStoreEditPriceRequest request2 = request;
				if (!TryResolveRequester(player, sender, out long playerId, out string _, out Vector3 _, out Quaternion _, out string reason))
				{
					return Fail("edit_price", reason);
				}
				if (!TryValidatePriceItems(request2.PriceItems, out List<ZoneBlueprintStorePriceItem> priceItems, out reason))
				{
					return Fail("edit_price", reason);
				}
				string platformId = ResolveRequesterPlatformId(player, sender, playerId);
				ZoneBlueprintStoreCatalog zoneBlueprintStoreCatalog = ZoneBlueprintStoreDraftRepository.LoadCatalog();
				ZoneBlueprintStoreDraftRepository.DeactivateExpiredListings(zoneBlueprintStoreCatalog);
				ZoneBlueprintStoreListing zoneBlueprintStoreListing = zoneBlueprintStoreCatalog.Listings.FirstOrDefault((ZoneBlueprintStoreListing item) => item.Active && string.Equals(item.ListingId, request2.ListingId, StringComparison.Ordinal));
				if (zoneBlueprintStoreListing == null)
				{
					return Fail("edit_price", HomesteadLocalization.Text("hs_store_listing_not_found"));
				}
				if (!IsStoreListingOwner(zoneBlueprintStoreListing, playerId, platformId))
				{
					return Fail("edit_price", HomesteadLocalization.Text("hs_store_edit_price_owner_only"));
				}
				zoneBlueprintStoreListing.PriceItems = priceItems;
				ZoneBlueprintStoreDraftRepository.SaveCatalog(zoneBlueprintStoreCatalog);
				return StatusWithListingPatch("edit_price", success: true, HomesteadLocalization.Format("hs_store_price_updated", zoneBlueprintStoreListing.Name, FormatPrice(priceItems)), zoneBlueprintStoreCatalog, zoneBlueprintStoreListing, playerId, platformId);
			}
		}

		private static class ZoneBlueprintStoreNotificationAction
		{
			public static ZoneBlueprintStoreRpcEnvelope ExecuteGet(Player? player, long sender)
			{
				if (!TryResolveRequester(player, sender, out long playerId, out string _, out Vector3 _, out Quaternion _, out string reason))
				{
					return Fail("get_notifications", reason);
				}
				string platformId = ResolveRequesterPlatformId(player, sender, playerId);
				ZoneBlueprintStoreCatalog catalog = ZoneBlueprintStoreDraftRepository.LoadCatalogReadOnly();
				return CreateEnvelope("get_notifications", new ZoneBlueprintStoreNotificationResponse
				{
					Notifications = GetUnreadNotifications(catalog, playerId, platformId)
				});
			}

			public static ZoneBlueprintStoreRpcEnvelope ExecuteRecent(ZoneBlueprintStoreRecentNotificationsRequest request, Player? player, long sender)
			{
				if (!TryResolveRequester(player, sender, out long playerId, out string _, out Vector3 _, out Quaternion _, out string reason))
				{
					return Fail("recent_notifications", reason);
				}
				string platformId = ResolveRequesterPlatformId(player, sender, playerId);
				ZoneBlueprintStoreCatalog catalog = ZoneBlueprintStoreDraftRepository.LoadCatalogReadOnly();
				return CreateEnvelope("recent_notifications", new ZoneBlueprintStoreNotificationResponse
				{
					Notifications = GetRecentNotifications(catalog, playerId, platformId, request.Limit)
				});
			}

			public static ZoneBlueprintStoreRpcEnvelope ExecuteRead(ZoneBlueprintStoreReadNotificationsRequest request, Player? player, long sender)
			{
				if (!TryResolveRequester(player, sender, out long playerId, out string _, out Vector3 _, out Quaternion _, out string reason))
				{
					return Fail("read_notifications", reason);
				}
				string platformId = ResolveRequesterPlatformId(player, sender, playerId);
				HashSet<string> hashSet = new HashSet<string>(request.NotificationIds ?? new List<string>(), StringComparer.Ordinal);
				if (hashSet.Count == 0)
				{
					return Status("read_notifications", success: true, "");
				}
				ZoneBlueprintStoreCatalog zoneBlueprintStoreCatalog = ZoneBlueprintStoreDraftRepository.LoadCatalog();
				ZoneBlueprintStoreCatalog zoneBlueprintStoreCatalog2 = zoneBlueprintStoreCatalog;
				if (zoneBlueprintStoreCatalog2.Notifications == null)
				{
					List<ZoneBlueprintStoreNotification> list2 = (zoneBlueprintStoreCatalog2.Notifications = new List<ZoneBlueprintStoreNotification>());
				}
				bool flag = false;
				foreach (ZoneBlueprintStoreNotification notification in zoneBlueprintStoreCatalog.Notifications)
				{
					if (hashSet.Contains(notification.NotificationId) && IsNotificationRecipient(notification, playerId, platformId))
					{
						MarkNotificationRead(notification, playerId, platformId);
						flag = true;
					}
				}
				if (flag)
				{
					PruneStoreNotifications(zoneBlueprintStoreCatalog);
					ZoneBlueprintStoreDraftRepository.SaveCatalog(zoneBlueprintStoreCatalog);
				}
				return Status("read_notifications", success: true, "");
			}
		}

		private static class ZoneBlueprintStoreOfferAction
		{
			public static ZoneBlueprintStoreRpcEnvelope ExecuteCreate(ZoneBlueprintStoreCreateOfferRequest request, Player? player, long sender)
			{
				ZoneBlueprintStoreCreateOfferRequest request2 = request;
				if (!TryResolveRequester(player, sender, out long buyerPlayerId, out string playerName, out Vector3 _, out Quaternion _, out string reason))
				{
					return Fail("create_offer", reason);
				}
				if (!TryValidatePriceItems(request2.PriceItems, out List<ZoneBlueprintStorePriceItem> priceItems, out reason))
				{
					return Fail("create_offer", reason);
				}
				string buyerPlatformId = ResolveRequesterPlatformId(player, sender, buyerPlayerId);
				ZoneBlueprintStoreCatalog zoneBlueprintStoreCatalog = ZoneBlueprintStoreDraftRepository.LoadCatalog();
				ZoneBlueprintStoreDraftRepository.DeactivateExpiredListings(zoneBlueprintStoreCatalog);
				ZoneBlueprintStoreListing listing = zoneBlueprintStoreCatalog.Listings.FirstOrDefault((ZoneBlueprintStoreListing item) => item.Active && string.Equals(item.ListingId, request2.ListingId, StringComparison.Ordinal));
				if (listing == null)
				{
					return Fail("create_offer", HomesteadLocalization.Text("hs_store_listing_not_found"));
				}
				if (IsStoreListingOwner(listing, buyerPlayerId, buyerPlatformId))
				{
					return Fail("create_offer", HomesteadLocalization.Text("hs_store_use_edit_price_own_listing"));
				}
				DateTime utcNow = DateTime.UtcNow;
				ZoneBlueprintStoreOffer zoneBlueprintStoreOffer = zoneBlueprintStoreCatalog.Offers.FirstOrDefault((ZoneBlueprintStoreOffer offer) => string.Equals(offer.ListingId, listing.ListingId, StringComparison.Ordinal) && IsOfferBuyer(offer, buyerPlayerId, buyerPlatformId) && string.Equals(offer.Status, "Pending", StringComparison.Ordinal));
				if (zoneBlueprintStoreOffer != null)
				{
					zoneBlueprintStoreOffer.PriceItems = priceItems;
					zoneBlueprintStoreOffer.BuyerName = playerName;
					zoneBlueprintStoreOffer.BuyerPlayerId = buyerPlayerId;
					zoneBlueprintStoreOffer.BuyerPlatformId = buyerPlatformId;
					zoneBlueprintStoreOffer.UpdatedAt = HomesteadTimestamp.Format(utcNow);
					AddOfferReceivedNotification(zoneBlueprintStoreCatalog, listing, zoneBlueprintStoreOffer, playerName, priceItems, updated: true);
					ZoneBlueprintStoreDraftRepository.SaveCatalog(zoneBlueprintStoreCatalog);
					PushLatestNotification(zoneBlueprintStoreCatalog);
					return StatusWithListingPatch("create_offer", success: true, HomesteadLocalization.Format("hs_store_offer_updated_status", listing.Name, FormatPrice(priceItems)), zoneBlueprintStoreCatalog, listing, buyerPlayerId, buyerPlatformId);
				}
				ZoneBlueprintStoreOffer zoneBlueprintStoreOffer2 = new ZoneBlueprintStoreOffer
				{
					OfferId = CreateOfferId(),
					ListingId = listing.ListingId,
					BuyerName = playerName,
					BuyerPlayerId = buyerPlayerId,
					BuyerPlatformId = buyerPlatformId,
					CreatedAt = HomesteadTimestamp.Format(utcNow),
					UpdatedAt = HomesteadTimestamp.Format(utcNow),
					Status = "Pending",
					PriceItems = priceItems
				};
				zoneBlueprintStoreCatalog.Offers.Add(zoneBlueprintStoreOffer2);
				AddOfferReceivedNotification(zoneBlueprintStoreCatalog, listing, zoneBlueprintStoreOffer2, playerName, priceItems, updated: false);
				ZoneBlueprintStoreDraftRepository.SaveCatalog(zoneBlueprintStoreCatalog);
				PushLatestNotification(zoneBlueprintStoreCatalog);
				return StatusWithListingPatch("create_offer", success: true, HomesteadLocalization.Format("hs_store_offer_sent_status", listing.Name, FormatPrice(priceItems)), zoneBlueprintStoreCatalog, listing, buyerPlayerId, buyerPlatformId);
			}

			public static ZoneBlueprintStoreRpcEnvelope ExecuteList(ZoneBlueprintStoreListOffersRequest request, Player? player, long sender)
			{
				ZoneBlueprintStoreListOffersRequest request2 = request;
				long playerId = 0L;
				string platformId = "";
				if (TryResolveRequester(player, sender, out long playerId2, out string _, out Vector3 _, out Quaternion _, out string _))
				{
					playerId = playerId2;
					platformId = ResolveRequesterPlatformId(player, sender, playerId);
				}
				ZoneBlueprintStoreCatalog zoneBlueprintStoreCatalog = ZoneBlueprintStoreDraftRepository.LoadCatalogReadOnly();
				ZoneBlueprintStoreDraftRepository.DeactivateExpiredListings(zoneBlueprintStoreCatalog);
				ZoneBlueprintStoreListing listing = zoneBlueprintStoreCatalog.Listings.FirstOrDefault((ZoneBlueprintStoreListing item) => item.Active && string.Equals(item.ListingId, request2.ListingId, StringComparison.Ordinal));
				if (listing == null)
				{
					return CreateEnvelope("list_offers", new ZoneBlueprintStoreListOffersResponse
					{
						Success = false,
						Message = HomesteadLocalization.Text("hs_store_listing_not_found"),
						ListingId = request2.ListingId
					});
				}
				bool canManage = IsStoreListingOwner(listing, playerId, platformId);
				return CreateEnvelope("list_offers", new ZoneBlueprintStoreListOffersResponse
				{
					Success = true,
					ListingId = listing.ListingId,
					ListingName = listing.Name,
					CanManage = canManage,
					Offers = (from offer in zoneBlueprintStoreCatalog.Offers.Where((ZoneBlueprintStoreOffer offer) => string.Equals(offer.ListingId, listing.ListingId, StringComparison.Ordinal) && !string.Equals(offer.Status, "Deleted", StringComparison.Ordinal)).OrderByDescending<ZoneBlueprintStoreOffer, string>((ZoneBlueprintStoreOffer offer) => offer.UpdatedAt, StringComparer.Ordinal)
						select ToOfferDto(offer, canManage, playerId, platformId)).ToList()
				});
			}

			public static ZoneBlueprintStoreRpcEnvelope ExecuteDecision(ZoneBlueprintStoreDecideOfferRequest request, Player? player, long sender)
			{
				ZoneBlueprintStoreDecideOfferRequest request2 = request;
				return ExecuteSellerOfferMutation("decide_offer", request2.ListingId, request2.OfferId, player, sender, delegate(ZoneBlueprintStoreListing listing, ZoneBlueprintStoreOffer offer)
				{
					string text = (request2.Decision ?? "").Trim().ToLowerInvariant();
					if (text == "accept")
					{
						if (!string.Equals(offer.Status, "Pending", StringComparison.Ordinal))
						{
							return HomesteadLocalization.Format("hs_store_offer_accept_pending_only", listing.Name);
						}
						offer.Status = "Accepted";
						offer.UpdatedAt = HomesteadTimestamp.Now();
						AddOfferDecisionNotification(ZoneBlueprintStoreOfferActionMutationContext.Catalog, listing, offer, accepted: true);
						return "";
					}
					if (text == "decline")
					{
						offer.Status = "Declined";
						offer.UpdatedAt = HomesteadTimestamp.Now();
						AddOfferDecisionNotification(ZoneBlueprintStoreOfferActionMutationContext.Catalog, listing, offer, accepted: false);
						return "";
					}
					return HomesteadLocalization.Text("hs_store_offer_unknown_decision");
				}, (ZoneBlueprintStoreListing listing, ZoneBlueprintStoreOffer offer) => (!string.Equals(offer.Status, "Accepted", StringComparison.Ordinal)) ? HomesteadLocalization.Format("hs_store_offer_decline_status", offer.BuyerName, listing.Name) : HomesteadLocalization.Format("hs_store_offer_accept_status", offer.BuyerName, listing.Name));
			}

			public static ZoneBlueprintStoreRpcEnvelope ExecuteDelete(ZoneBlueprintStoreDeleteOfferRequest request, Player? player, long sender)
			{
				if (!TryResolveRequester(player, sender, out long playerId, out string _, out Vector3 _, out Quaternion _, out string reason))
				{
					return Fail("delete_offer", reason);
				}
				string platformId = ResolveRequesterPlatformId(player, sender, playerId);
				ZoneBlueprintStoreCatalog catalog = ZoneBlueprintStoreDraftRepository.LoadCatalog();
				ZoneBlueprintStoreDraftRepository.DeactivateExpiredListings(catalog);
				if (!TryGetListingAndOffer(catalog, request.ListingId, request.OfferId, out ZoneBlueprintStoreListing listing, out ZoneBlueprintStoreOffer offer, out reason))
				{
					return Fail("delete_offer", reason);
				}
				bool num = IsStoreListingOwner(listing, playerId, platformId);
				bool flag = IsOfferBuyer(offer, playerId, platformId);
				if (!num && !flag)
				{
					return Fail("delete_offer", HomesteadLocalization.Text("hs_store_offer_delete_owner_only"));
				}
				offer.Status = "Deleted";
				offer.UpdatedAt = HomesteadTimestamp.Now();
				ZoneBlueprintStoreDraftRepository.SaveCatalog(catalog);
				return StatusWithListingPatch("delete_offer", success: true, HomesteadLocalization.Format("hs_store_offer_deleted_status", offer.BuyerName, listing.Name), catalog, listing, playerId, platformId);
			}

			private static ZoneBlueprintStoreRpcEnvelope ExecuteSellerOfferMutation(string responseType, string listingId, string offerId, Player? player, long sender, Func<ZoneBlueprintStoreListing, ZoneBlueprintStoreOffer, string> mutate, Func<ZoneBlueprintStoreListing, ZoneBlueprintStoreOffer, string> successMessage)
			{
				if (!TryResolveRequester(player, sender, out long playerId, out string _, out Vector3 _, out Quaternion _, out string reason))
				{
					return Fail(responseType, reason);
				}
				string platformId = ResolveRequesterPlatformId(player, sender, playerId);
				ZoneBlueprintStoreCatalog zoneBlueprintStoreCatalog = (ZoneBlueprintStoreOfferActionMutationContext.Catalog = ZoneBlueprintStoreDraftRepository.LoadCatalog());
				ZoneBlueprintStoreDraftRepository.DeactivateExpiredListings(zoneBlueprintStoreCatalog);
				int num = zoneBlueprintStoreCatalog.Notifications?.Count ?? 0;
				if (!TryGetListingAndOffer(zoneBlueprintStoreCatalog, listingId, offerId, out ZoneBlueprintStoreListing listing, out ZoneBlueprintStoreOffer offer, out reason))
				{
					ZoneBlueprintStoreOfferActionMutationContext.Catalog = null;
					return Fail(responseType, reason);
				}
				if (!IsStoreListingOwner(listing, playerId, platformId))
				{
					ZoneBlueprintStoreOfferActionMutationContext.Catalog = null;
					return Fail(responseType, HomesteadLocalization.Text("hs_store_offer_manage_seller_only"));
				}
				string text = mutate(listing, offer);
				if (!string.IsNullOrWhiteSpace(text))
				{
					ZoneBlueprintStoreOfferActionMutationContext.Catalog = null;
					return Fail(responseType, text);
				}
				ZoneBlueprintStoreDraftRepository.SaveCatalog(zoneBlueprintStoreCatalog);
				if ((zoneBlueprintStoreCatalog.Notifications?.Count ?? 0) > num)
				{
					PushLatestNotification(zoneBlueprintStoreCatalog);
				}
				string message = successMessage(listing, offer);
				ZoneBlueprintStoreOfferActionMutationContext.Catalog = null;
				return StatusWithListingPatch(responseType, success: true, message, zoneBlueprintStoreCatalog, listing, playerId, platformId);
			}
		}

		private static class ZoneBlueprintStoreOfferActionMutationContext
		{
			public static ZoneBlueprintStoreCatalog? Catalog;
		}

		private static class ZoneBlueprintStorePreviewAction
		{
			private const int PreviewRestorePayloadCacheLimit = 64;

			private static readonly Dictionary<string, byte[]> PreviewRestorePayloadCache = new Dictionary<string, byte[]>(StringComparer.OrdinalIgnoreCase);

			private static readonly Queue<string> PreviewRestorePayloadCacheOrder = new Queue<string>();

			public static void ResetPreviewRestorePayloadCache()
			{
				PreviewRestorePayloadCache.Clear();
				PreviewRestorePayloadCacheOrder.Clear();
			}

			public static ZoneBlueprintStoreRpcEnvelope ExecutePreview(ZoneBlueprintStorePreviewRequest request)
			{
				if (!TryLoadListingBlueprint(request.ListingId, out ZoneBlueprintStoreListing listing, out ZoneBlueprintFile blueprint, out string reason))
				{
					return CreateEnvelope("preview", new ZoneBlueprintStorePreviewResponse
					{
						Success = false,
						Message = reason,
						ListingId = request.ListingId
					});
				}
				if (!ZoneBlueprintNetworkPayload.TryCreatePreviewPayload(blueprint, out byte[] payload, out reason))
				{
					return CreateEnvelope("preview", new ZoneBlueprintStorePreviewResponse
					{
						Success = false,
						Message = reason,
						ListingId = request.ListingId
					});
				}
				return CreateEnvelope("preview", new ZoneBlueprintStorePreviewResponse
				{
					Success = true,
					ListingId = listing.ListingId,
					OfferId = request.OfferId,
					Name = listing.Name,
					BlueprintEncoding = "gzip",
					BlueprintPayload = payload
				});
			}

			public static ZoneBlueprintStoreRpcEnvelope ExecutePreviewRestore(ZoneBlueprintStorePreviewRestoreRequest request, Player? player, long sender)
			{
				string mode = request.Mode;
				ZoneBlueprintStoreListing listing = null;
				string name = request.Name;
				string blueprintFile = request.BlueprintFile;
				ZoneBlueprintFile blueprint;
				if (string.Equals(mode, "buy", StringComparison.Ordinal))
				{
					if (!TryLoadListingBlueprint(request.ListingId, out listing, out blueprint, out string reason))
					{
						return FailPreviewRestore(mode, request.ListingId, name, blueprintFile, reason);
					}
					name = listing.Name;
					blueprintFile = listing.BlueprintFile;
				}
				else
				{
					if (!string.Equals(mode, "price", StringComparison.Ordinal))
					{
						return FailPreviewRestore(mode, request.ListingId, name, blueprintFile, "Unknown store preview mode.");
					}
					if (!TryResolvePriceDraftRestore(request, out name, out blueprintFile, out string reason2))
					{
						return FailPreviewRestore(mode, request.ListingId, name, blueprintFile, reason2);
					}
					if (!ZoneBlueprintStoreDraftRepository.TryLoadBlueprintFile(blueprintFile, out blueprint, out reason2))
					{
						return FailPreviewRestore(mode, request.ListingId, name, blueprintFile, reason2);
					}
					if (string.IsNullOrWhiteSpace(name))
					{
						name = blueprint.Name;
					}
				}
				if (!TryGetPreviewRestorePayload(blueprintFile, blueprint, out byte[] payload, out string reason3))
				{
					return FailPreviewRestore(mode, request.ListingId, name, blueprintFile, reason3);
				}
				return CreateEnvelope("preview_restore", new ZoneBlueprintStorePreviewRestoreResponse
				{
					Mode = mode,
					Success = true,
					ListingId = request.ListingId,
					Name = name,
					BlueprintFile = blueprintFile,
					BlueprintEncoding = "gzip",
					BlueprintPayload = payload
				});
			}

			private static bool TryGetPreviewRestorePayload(string blueprintFile, ZoneBlueprintFile blueprint, out byte[] payload, out string reason)
			{
				string text = CreatePreviewRestoreCacheKey(blueprintFile);
				if (PreviewRestorePayloadCache.TryGetValue(text, out byte[] value))
				{
					payload = value;
					reason = "";
					return true;
				}
				if (!ZoneBlueprintNetworkPayload.TryCreatePreviewPayload(blueprint, out payload, out reason))
				{
					return false;
				}
				PreviewRestorePayloadCache[text] = payload;
				PreviewRestorePayloadCacheOrder.Enqueue(text);
				while (PreviewRestorePayloadCache.Count > 64 && PreviewRestorePayloadCacheOrder.Count > 0)
				{
					string key = PreviewRestorePayloadCacheOrder.Dequeue();
					PreviewRestorePayloadCache.Remove(key);
				}
				return true;
			}

			private static string CreatePreviewRestoreCacheKey(string blueprintFile)
			{
				string fileName = Path.GetFileName(blueprintFile ?? "");
				DateTime writeUtc;
				long num = (ZoneBlueprintStoreDraftRepository.TryGetBlueprintFileWriteUtc(fileName, out writeUtc) ? writeUtc.Ticks : 0);
				BlueprintNetworkSettings networkSettings = BlueprintConfig.NetworkSettings;
				return $"{fileName}|{num}|{networkSettings.MaxPreviewEntries}|{networkSettings.MaxUploadBytes}";
			}

			private static ZoneBlueprintStoreRpcEnvelope FailPreviewRestore(string mode, string listingId, string name, string blueprintFile, string message)
			{
				return CreateEnvelope("preview_restore", new ZoneBlueprintStorePreviewRestoreResponse
				{
					Mode = mode,
					Success = false,
					Message = message,
					ListingId = listingId,
					Name = name,
					BlueprintFile = blueprintFile
				});
			}

			private static bool TryResolvePriceDraftRestore(ZoneBlueprintStorePreviewRestoreRequest request, out string name, out string blueprintFile, out string reason)
			{
				name = request.Name;
				blueprintFile = Path.GetFileName(request.BlueprintFile ?? "");
				reason = "";
				if (ZoneBlueprintStoreChestRegistry.TryResolvePriceDraftRestore(request.ListingId, blueprintFile, out string name2, out string resolvedBlueprintFile))
				{
					name = (string.IsNullOrWhiteSpace(name2) ? name : name2);
					blueprintFile = resolvedBlueprintFile;
					return true;
				}
				reason = "Blueprint store draft preview is not available.";
				return false;
			}
		}

		private static class ZoneBlueprintStorePurchaseAction
		{
			public static ZoneBlueprintStoreRpcEnvelope ExecuteBuy(ZoneBlueprintStoreBuyRequest request, Player? player, long sender)
			{
				//IL_00ce: 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_00d2: 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_00d5: 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_00e4: 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_010e: Unknown result type (might be due to invalid IL or missing references)
				//IL_010f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0120: Unknown result type (might be due to invalid IL or missing references)
				//IL_0125: Unknown result type (might be due to invalid IL or missing references)
				//IL_012a: Unknown result type (might be due to invalid IL or missing references)
				//IL_012f: 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_013a: 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_0104: 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_0108: Unknown result type (might be due to invalid IL or missing references)
				//IL_010a: Unknown result type (might be due to invalid IL or missing references)
				//IL_015d: Unknown result type (might be due to invalid IL or missing references)
				//IL_015e: 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_018c: Unknown result type (might be due to invalid IL or missing references)
				//IL_018e: 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_0192: 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_01fa: Unknown result type (might be due to invalid IL or missing references)
				ZoneBlueprintStoreBuyRequest request2 = request;
				if (!TryResolveRequester(player, sender, out long playerId, out string playerName, out Vector3 position, out Quaternion rotation, out string reason))
				{
					return FailBuy(reason);
				}
				if (!TryLoadListingBlueprint(request2.ListingId, out ZoneBlueprintStoreListing listing, out ZoneBlueprintFile _, out reason))
				{
					return FailBuy(reason);
				}
				string text = ResolveRequesterPlatformId(player, sender, playerId);
				if (IsStoreListingOwner(listing, playerId, text))
				{
					return FailBuy(HomesteadLocalization.Text("hs_store_use_edit_price_own_listing"));
				}
				List<ZoneBlueprintStorePriceItem> priceItems = GetListingPriceItems(listing);
				if (!string.IsNullOrWhiteSpace(request2.OfferId))
				{
					ZoneBlueprintStoreCatalog catalog = ZoneBlueprintStoreDraftRepository.LoadCatalogReadOnly();
					ZoneBlueprintStoreDraftRepository.DeactivateExpiredListings(catalog);
					if (!TryGetAcceptedBuyerOffer(catalog, listing.ListingId, request2.OfferId, playerId, text, out ZoneBlueprintStoreOffer offer, out reason))
					{
						return FailBuy(reason);
					}
					priceItems = NormalizePriceItems(offer.PriceItems);
				}
				Quaternion rotation2 = rotation;
				Vector3 position2 = position;
				Quaternion rotation3 = rotation;
				if (!TryReadOptionalStoreChestTarget(request2.Target, position, rotation, out bool hasTarget, out Vector3 position3, out Quaternion rotation4, out reason))
				{
					return FailBuy(reason);
				}
				Vector3 val;
				if (hasTarget)
				{
					val = position3;
					rotation2 = rotation4;
				}
				else
				{
					val = position + rotation * new Vector3(0f, 0f, 2.2f);
					val.y = SampleGroundY(val.x, val.z, val.y);
				}
				if (!TryReadOptionalStorePreviewAnchor(request2.PreviewAnchor, position, position2, rotation3, out position2, out rotation3, out reason))
				{
					return FailBuy(reason);
				}
				HomesteadCommandResult homesteadCommandResult = ZoneBlueprintStoreChestPrefab.PlacePurchaseChest(listing, priceItems, request2.OfferId, playerId, playerName, text, val, rotation2, position2, rotation3, sender);
				return CreateEnvelope("buy", new ZoneBlueprintStoreBuyResponse
				{
					Success = homesteadCommandResult.Success,
					Message = homesteadCommandResult.Message,
					ListingId = listing.ListingId,
					OfferId = request2.OfferId,
					Name = listing.Name,
					Chest = (homesteadCommandResult.Success ? ToTransformPayload(val, rotation2) : null)
				});
				ZoneBlueprintStoreRpcEnvelope FailBuy(string message)
				{
					return CreateEnvelope("buy", new ZoneBlueprintStoreBuyResponse
					{
						Success = false,
						Message = message,
						ListingId = request2.ListingId
					});
				}
			}

			public static ZoneBlueprintStoreRpcEnvelope ExecuteConfirmResponse(ZoneBlueprintStoreConfirmPurchaseRequest request, Player? player, long sender)
			{
				if (!TryResolveRequester(player, sender, out long playerId, out string playerName, out Vector3 _, out Quaternion _, out string reason))
				{
					return Fail("confirm", reason);
				}
				HomesteadCommandResult homesteadCommandResult = ExecuteConfirm(request.ListingId, playerId, playerName, sender, null, request.OfferId);
				return Status("confirm", homesteadCommandResult.Success, homesteadCommandResult.Message);
			}

			public static HomesteadCommandResult ExecuteConfirm(string listingId, long buyerPlayerId, string buyerName, long targetPeer, ZoneBlueprintStoreChest? directChest, string offerId = "")
			{
				string listingId2 = listingId;
				buyerName = (string.IsNullOrWhiteSpace(buyerName) ? HomesteadLocalization.Text("hs_common_unknown") : buyerName);
				ZoneBlueprintStoreCatalog zoneBlueprintStoreCatalog = ZoneBlueprintStoreDraftRepository.LoadCatalog();
				ZoneBlueprintStoreDraftRepository.DeactivateExpiredListings(zoneBlueprintStoreCatalog);
				ZoneBlueprintStoreListing zoneBlueprintStoreListing = zoneBlueprintStoreCatalog.Listings.FirstOrDefault((ZoneBlueprintStoreListing item) => item.Active && item.ListingId == listingId2);
				if (zoneBlueprintStoreListing == null)
				{
					return HomesteadCommandResult.Fail(HomesteadLocalization.Text("hs_store_listing_not_found"));
				}
				ZoneBlueprintStoreActor zoneBlueprintStoreActor = ResolveRequesterActor(null, targetPeer, buyerPlayerId);
				string platformId = zoneBlueprintStoreActor.PlatformId;
				if (IsStoreListingOwner(zoneBlueprintStoreListing, zoneBlueprintStoreActor))
				{
					return HomesteadCommandResult.Fail(HomesteadLocalization.Text("hs_store_use_edit_price_own_listing"));
				}
				offerId = ((string.IsNullOrWhiteSpace(offerId) && (Object)(object)directChest != (Object)null) ? directChest.GetOfferId() : offerId);
				ZoneBlueprintStoreChest zoneBlueprintStoreChest = directChest ?? FindPurchaseChest(listingId2, zoneBlueprintStoreActor, offerId);
				ZDO zdo = null;
				if ((Object)(object)zoneBlueprintStoreChest == (Object)null && !ZoneBlueprintStoreChestRegistry.TryFindPurchaseChestZdo(listingId2, zoneBlueprintStoreActor, offerId, out zdo))
				{
					return HomesteadCommandResult.Fail(HomesteadLocalization.Text("hs_store_purchase_chest_missing_nearby"));
				}
				if (string.IsNullOrWhiteSpace(offerId) && zdo != null)
				{
					offerId = zdo.GetString("hs_store_offer", "");
				}
				List<ZoneBlueprintStorePriceItem> list = GetListingPriceItems(zoneBlueprintStoreListing);
				ZoneBlueprintStoreOffer offer = null;
				if (!string.IsNullOrWhiteSpace(offerId))
				{
					if (!TryGetAcceptedBuyerOffer(zoneBlueprintStoreCatalog, zoneBlueprintStoreListing.ListingId, offerId, buyerPlayerId, platformId, out offer, out string reason))
					{
						return HomesteadCommandResult.Fail(reason);
					}
					list = NormalizePriceItems(offer.PriceItems);
				}
				if (!(((Object)(object)zoneBlueprintStoreChest != (Object)null) ? zoneBlueprintStoreChest.CanTakePriceItems(list, out string deposited) : ZoneBlueprintStoreChest.CanTakePurchasePriceItems(zdo, list, out deposited)))
				{
					return HomesteadCommandResult.Fail(HomesteadLocalization.Format("hs_store_deposit_price_first", deposited));
				}
				if (!ZoneBlueprintStoreDraftRepository.TryLoadBlueprintFile(zoneBlueprintStoreListing.BlueprintFile, out ZoneBlueprintFile blueprint, out string reason2))
				{
					return HomesteadCommandResult.Fail(reason2);
				}
				if (!ZoneBlueprintNetworkPayload.TryCreateBlueprintPayload(HomesteadYaml.Serialize(blueprint), enforceUploadLimit: false, out byte[] payload, out string reason3))
				{
					return HomesteadCommandResult.Fail(reason3);
				}
				if (!(((Object)(object)zoneBlueprintStoreChest != (Object)null) ? zoneBlueprintStoreChest.TryTakePriceItems(list, out deposited) : ZoneBlueprintStoreChest.TryTakePurchasePriceItems(zdo, list, out deposited)))
				{
					return HomesteadCommandResult.Fail(HomesteadLocalization.Format("hs_store_deposit_price_first", deposited));
				}
				CreditSeller(zoneBlueprintStoreCatalog, zoneBlueprintStoreListing, list, incrementPurchaseCount: true);
				AddPurchaseNotification(zoneBlueprintStoreCatalog, zoneBlueprintStoreListing, buyerName, list, offerId);
				ZoneBlueprintStoreDraftRepository.SaveCatalog(zoneBlueprintStoreCatalog, immediate: true);
				PushLatestNotification(zoneBlueprintStoreCatalog);
				if ((Object)(object)zoneBlueprintStoreChest != (Object)null)
				{
					zoneBlueprintStoreChest.MarkConfirmed();
					zoneBlueprintStoreChest.DestroyChest();
				}
				else
				{
					ZoneBlueprintStoreChest.MarkConfirmed(zdo);
					if (zdo != null)
					{
						SavedZdoHelper.Destroy(zdo);
						SavedZdoHelper.FlushDestroyed();
					}
				}
				ZoneBlueprintStoreRpcEnvelope zoneBlueprintStoreRpcEnvelope = CreateEnvelope("purchase_complete", new ZoneBlueprintStorePurchaseCompleteResponse
				{
					Success = true,
					Message = HomesteadLocalization.Format("hs_store_purchased", zoneBlueprintStoreListing.Name, FormatPrice(list)),
					ListingId = zoneBlueprintStoreListing.ListingId,
					OfferId = offerId,
					Name = zoneBlueprintStoreListing.Name,
					BlueprintEncoding = "gzip",
					BlueprintPayload = payload
				});
				if (targetPeer != 0L && ZRoutedRpc.instance != null)
				{
					SendResponse(targetPeer, zoneBlueprintStoreRpcEnvelope);
				}
				else
				{
					HandleResponse(zoneBlueprintStoreRpcEnvelope);
				}
				return HomesteadCommandResult.Ok(ReadPayload<ZoneBlueprintStorePurchaseCompleteResponse>(zoneBlueprintStoreRpcEnvelope).Message);
			}
		}

		private static class ZoneBlueprintStoreWithdrawAction
		{
			public static ZoneBlueprintStoreRpcEnvelope Execute(ZoneBlueprintStoreWithdrawRequest request, Player? player, long sender)
			{
				//IL_012a: Unknown result type (might be due to invalid IL or missing references)
				//IL_012b: Unknown result type (might be due to invalid IL or missing references)
				//IL_012d: Unknown result type (might be due to invalid IL or missing references)
				//IL_012f: 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_0138: Unknown result type (might be due to invalid IL or missing references)
				//IL_017f: Unknown result type (might be due to invalid IL or missing references)
				//IL_017c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0189: Unknown result type (might be due to invalid IL or missing references)
				//IL_0185: Unknown result type (might be due to invalid IL or missing references)
				if (!TryResolveRequester(player, sender, out long playerId, out string playerName, out Vector3 position, out Quaternion rotation, out string reason))
				{
					return Fail("withdraw", reason);
				}
				ZoneBlueprintStoreActor seller = ResolveRequesterActor(player, sender, playerId);
				ZoneBlueprintStoreCatalog zoneBlueprintStoreCatalog = ZoneBlueprintStoreDraftRepository.LoadCatalog();
				ZoneBlueprintStoreDraftRepository.DeactivateExpiredListings(zoneBlueprintStoreCatalog);
				List<ZoneBlueprintStoreBalance> list = zoneBlueprintStoreCatalog.Balances.Where((ZoneBlueprintStoreBalance item) => seller.MatchesStored(item.SellerPlayerId, item.SellerPlatformId, BlueprintConfig.StoreIdentityMode)).ToList();
				int num = list.Sum((ZoneBlueprintStoreBalance item) => item.Coins);
				List<ZoneBlueprintStorePriceItem> list2 = NormalizePriceItems(list.SelectMany((ZoneBlueprintStoreBalance item) => item.Materials));
				if (num <= 0 && list2.Count == 0)
				{
					return Fail("withdraw", HomesteadLocalization.Text("hs_store_no_balance_withdraw"));
				}
				List<ZoneBlueprintStorePriceItem> payoutItems = CreatePayoutItems(num, list2);
				List<ZoneBlueprintStoreBalance> snapshots = CloneBalances(list);
				ClearBalances(list, playerName, seller.PlatformId);
				if (!ZoneBlueprintStoreDraftRepository.TrySaveCatalogImmediate(zoneBlueprintStoreCatalog, out string reason2))
				{
					RestoreBalances(list, snapshots);
					ZoneBlueprintStoreDraftRepository.SaveCatalog(zoneBlueprintStoreCatalog);
					return Fail("withdraw", reason2);
				}
				Vector3 position2 = position;
				Quaternion rotation2 = rotation;
				string reason3;
				if (!TryReadOptionalStoreChestTarget(request.Target, position, rotation, out bool hasTarget, out position2, out rotation2, out reason))
				{
					RestoreBalances(list, snapshots);
					ZoneBlueprintStoreDraftRepository.TrySaveCatalogImmediate(zoneBlueprintStoreCatalog, out reason3);
					return Fail("withdraw", reason);
				}
				List<ZoneBlueprintStoreTransformPayload> chestTransforms;
				HomesteadCommandResult homesteadCommandResult = ZoneBlueprintStoreChestPrefab.PlacePayoutChests(payoutItems, playerId, playerName, seller.PlatformId, hasTarget ? position2 : position, hasTarget ? rotation2 : rotation, hasTarget, out chestTransforms, sender);
				if (!homesteadCommandResult.Success)
				{
					RestoreBalances(list, snapshots);
					ZoneBlueprintStoreDraftRepository.TrySaveCatalogImmediate(zoneBlueprintStoreCatalog, out reason3);
					return Fail("withdraw", homesteadCommandResult.Message);
				}
				return CreateEnvelope("withdraw_complete", new ZoneBlueprintStoreWithdrawResponse
				{
					Success = true,
					Message = HomesteadLocalization.Format("hs_store_withdraw_complete", homesteadCommandResult.Message, FormatBalance(num, list2)),
					Chests = chestTransforms
				});
			}

			private static List<ZoneBlueprintStoreBalance> CloneBalances(IEnumerable<ZoneBlueprintStoreBalance> balances)
			{
				return balances.Select((ZoneBlueprintStoreBalance balance) => new ZoneBlueprintStoreBalance
				{
					SellerPlayerId = balance.SellerPlayerId,
					SellerPlatformId = balance.SellerPlatformId,
					SellerName = balance.SellerName,
					Coins = balance.Coins,
					Materials = (balance.Materials?.Select((ZoneBlueprintStorePriceItem item) => new ZoneBlueprintStorePriceItem
					{
						ItemName = item.ItemName,
						PrefabName = item.PrefabName,
						DisplayName = item.DisplayName,
						Amount = item.Amount
					}).ToList() ?? new List<ZoneBlueprintStorePriceItem>())
				}).ToList();
			}

			private static void ClearBalances(IEnumerable<ZoneBlueprintStoreBalance> balances, string sellerName, string sellerPlatformId)
			{
				foreach (ZoneBlueprintStoreBalance balance in balances)
				{
					balance.Coins = 0;
					balance.SellerName = sellerName;
					balance.SellerPlatformId = sellerPlatformId;
					balance.Materials = new List<ZoneBlueprintStorePriceItem>();
				}
			}

			private static void RestoreBalances(IReadOnlyList<ZoneBlueprintStoreBalance> balances, IReadOnlyList<ZoneBlueprintStoreBalance> snapshots)
			{
				for (int i = 0; i < balances.Count && i < snapshots.Count; i++)
				{
					ZoneBlueprintStoreBalance zoneBlueprintStoreBalance = balances[i];
					ZoneBlueprintStoreBalance zoneBlueprintStoreBalance2 = snapshots[i];
					zoneBlueprintStoreBalance.SellerPlayerId = zoneBlueprintStoreBalance2.SellerPlayerId;
					zoneBlueprintStoreBalance.SellerPlatformId = zoneBlueprintStoreBalance2.SellerPlatformId;
					zoneBlueprintStoreBalance.SellerName = zoneBlueprintStoreBalance2.SellerName;
					zoneBlueprintStoreBalance.Coins = zoneBlueprintStoreBalance2.Coins;
					zoneBlueprintStoreBalance.Materials = zoneBlueprintStoreBalance2.Materials;
				}
			}
		}

		private const float ListingRefreshCoalesceDelay = 0.25f;

		internal const int StoreListingIconPageSize = 6;

		internal const int StoreListingMaxPageSize = 50;

		private static ManualLogSource _logger = null;

		private static bool _initialized;

		private static float _pendingListingRefreshAt = -1f;

		private static readonly Dictionary<string, HashSet<string>> HiddenListingIdsByRequester = new Dictionary<string, HashSet<string>>(StringComparer.Ordinal);

		private const float OrphanDraftSweepInterval = 300f;

		private static float _nextOrphanDraftSweep;

		private const float RecentNotificationOpenDelay = 1f;

		private const int RecentNotificationLimit = 32;

		private const int StoreNotificationRetainCount = 1024;

		private const int StoreNotificationReadMarkerRetainCount = 1024;

		private static float _nextNotificationPoll;

		private static float _pendingRecentNotificationRequest = -1f;

		private const float StoreChestAimDistance = 128f;

		private const float StoreChestPlacementMaxDistance = 136f;

		private const float StorePreviewAnchorMaxDistance = 160f;

		private const float StorePreviewAnchorMaxVerticalDelta = 64f;

		private const string RequestRpcName = "sighsorry.Homestead_BlueprintStoreRequest";

		private const string ResponseRpcName = "sighsorry.Homestead_BlueprintStoreResponse";

		private static readonly ZoneRpcRegistrar RpcRegistrar = new ZoneRpcRegistrar();

		private const string StoreCompleteVfxPrefab = "vfx_HealthUpgrade";

		private static bool _storeCompleteVfxMissingLogged;

		private static ZoneBlueprintStoreRpcEnvelope ExecuteRequest(ZoneBlueprintStoreRpcEnvelope request, Player? player, long sender)
		{
			return ZoneBlueprintStoreRequestDispatcher.Execute(request, player, sender);
		}

		private static HomesteadCommandResult ExecuteConfirm(string listingId, long buyerPlayerId, string buyerName, long targetPeer, ZoneBlueprintStoreChest? directChest, string offerId = "")
		{
			return ZoneBlueprintStorePurchaseAction.ExecuteConfirm(listingId, buyerPlayerId, buyerName, targetPeer, directChest, offerId);
		}

		private static HomesteadCommandResult ExecuteConfirmListing(string listingId, long sellerPlayerId, long targetPeer, ZoneBlueprintStoreChest? directChest, IReadOnlyList<ZoneBlueprintStorePriceItem>? overridePriceItems = null)
		{
			return ZoneBlueprintStoreListingAction.ExecuteConfirmListing(listingId, ResolveRequesterActor(null, targetPeer, sellerPlayerId), targetPeer, directChest, overridePriceItems);
		}

		private static ZoneBlueprintStoreChest? FindPurchaseChest(string listingId, ZoneBlueprintStoreActor buyer, string offerId = "")
		{
			return ZoneBlueprintStoreChestLookup.FindPurchaseChest(listingId, buyer, offerId);
		}

		private static ZoneBlueprintStoreChest? FindPriceChest(string listingId, ZoneBlueprintStoreActor seller)
		{
			return ZoneBlueprintStoreChestLookup.FindPriceChest(listingId, seller);
		}

		private static bool TryLoadListingBlueprint(string listingId, out ZoneBlueprintStoreListing listing, out ZoneBlueprintFile blueprint, out string reason)
		{
			blueprint = null;
			if (!TryLoadListing(listingId, out listing, out reason))
			{
				return false;
			}
			if (!ZoneBlueprintStoreDraftRepository.TryLoadBlueprintFile(listing.BlueprintFile, out blueprint, out reason))
			{
				return false;
			}
			return true;
		}

		private static bool TryLoadListing(string listingId, out ZoneBlueprintStoreListing listing, out string reason)
		{
			string listingId2 = listingId;
			listing = null;
			reason = "";
			ZoneBlueprintStoreCatalog zoneBlueprintStoreCatalog = ZoneBlueprintStoreDraftRepository.LoadCatalogReadOnly();
			ZoneBlueprintStoreDraftRepository.DeactivateExpiredListings(zoneBlueprintStoreCatalog);
			listing = zoneBlueprintStoreCatalog.Listings.FirstOrDefault((ZoneBlueprintStoreListing item) => item.Active && item.ListingId == listingId2);
			if (listing == null)
			{
				reason = HomesteadLocalization.Text("hs_store_listing_not_found");
				return false;
			}
			return true;
		}

		private static string ValidateStoreBlueprint(ZoneBlueprintFile blueprint)
		{
			if (blueprint.Entries.Count == 0)
			{
				return HomesteadLocalization.Text("hs_store_blueprint_no_entries");
			}
			if (!ZoneBlueprintNetworkPayload.TryValidateBlueprintEntryCount(blueprint, upload: true, out string reason))
			{
				return reason;
			}
			if ((Object)(object)ZNetScene.instance == (Object)null)
			{
				return HomesteadLocalization.Text("hs_common_world_not_ready");
			}
			foreach (ZoneBlueprintEntry entry in blueprint.Entries)
			{
				GameObject prefab = ZNetScene.instance.GetPrefab(entry.Prefab);
				if (!Object.op_Implicit((Object)(object)prefab) || (Object)(object)prefab.GetComponent<WearNTear>() == (Object)null || !ZoneBlueprintCommands.HasBuildRecipe(prefab))
				{
					return HomesteadLocalization.Format("hs_store_blueprint_unsupported_prefab", entry.Prefab);
				}
			}
			return "";
		}

		public static void Initialize(ManualLogSource logger)
		{
			if (!_initialized)
			{
				_initialized = true;
				_logger = logger;
				ZoneBlueprintStoreRuntime.Initialize(logger);
				RegisterRpcs();
			}
		}

		public static void Update()
		{
			RegisterRpcs();
			ZoneBlueprintStoreRuntime.Update();
			RunPendingListingRefresh();
			RequestPendingRecentNotifications();
			RequestNotificationsIfDue();
			RunOrphanDraftSweepIfDue();
		}

		public static void ResetForWorldSession()
		{
			ResetNotificationSession();
			_pendingListingRefreshAt = -1f;
			ZoneBlueprintStoreUi.ResetForWorldSession();
			ZoneBlueprintStoreOffersUi.ResetForWorldSession();
			ZoneBlueprintStorePreviewAction.ResetPreviewRestorePayloadCache();
			ZoneBlueprintStoreChest.ResetPreviewRestoreCacheForWorldSession();
			ZoneBlueprintStorePreviewTool.DeactivateActive();
		}

		public static void Open(Player player)
		{
			ZoneBlueprintStorePreviewTool.DeactivateActive();
			if (ZoneBlueprintStoreUi.Open())
			{
				ZoneBlueprintStoreUi.RequestCurrentPage(null, includeNotifications: true);
				ScheduleRecentNotifications();
			}
		}

		public static void OpenSellDialog(string blueprintName)
		{
			OpenPriceChestPreview(blueprintName, Player.m_localPlayer);
		}

		public static void OpenPriceChest(string blueprintName, Player? player)
		{
			//IL_008a: 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)
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			blueprintName = (blueprintName ?? "").Trim();
			if (string.IsNullOrWhiteSpace(blueprintName))
			{
				Message(HomesteadLocalization.Text("hs_store_blueprint_name_required"), (MessageType)2);
				return;
			}
			string yaml;
			try
			{
				yaml = ZoneBlueprintCommands.SerializeBlueprintForStore(blueprintName);
			}
			catch (Exception ex)
			{
				Message(HomesteadLocalization.Format("hs_store_blueprint_load_failed", blueprintName, ex.Message), (MessageType)2);
				return;
			}
			if (!ZoneBlueprintNetworkPayload.TryCreateBlueprintPayload(yaml, enforceUploadLimit: true, out byte[] payload, out string reason))
			{
				Message(reason, (MessageType)2);
				return;
			}
			Vector3 position;
			Quaternion rotation;
			ZoneBlueprintStoreTransformPayload target = (TryGetStoreChestPlacement(player, out position, out rotation) ? ToTransformPayload(position, rotation) : null);
			DispatchRequest("price_chest", new ZoneBlueprintStorePriceChestRequest
			{
				Name = blueprintName,
				BlueprintEncoding = "gzip",
				BlueprintPayload = payload,
				IconPngBase64 = ZoneBlueprintVisuals.GetIconPngBase64(blueprintName),
				Target = target
			}, player);
		}

		public static void OpenPriceChestPreview(string blueprintName, Player? player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			blueprintName = (blueprintName ?? "").Trim();
			if (string.IsNullOrWhiteSpace(blueprintName))
			{
				Message(HomesteadLocalization.Text("hs_store_blueprint_name_required"), (MessageType)2);
				return;
			}
			try
			{
				ZoneBlueprintFile blueprint = HomesteadYaml.Deserialize<ZoneBlueprintFile>(ZoneBlueprintCommands.SerializeBlueprintForStore(blueprintName));
				ZoneBlueprintStorePreviewTool.ActivateListing(blueprintName, blueprint);
				Hud.HidePieceSelection();
			}
			catch (Exception ex)
			{
				Message(HomesteadLocalization.Format("hs_store_blueprint_load_failed", blueprintName, ex.Message), (MessageType)2);
			}
		}

		public static void OpenPriceChestAt(string blueprintName, Vector3 chestPosition, Quaternion chestRotation)
		{
			//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_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			OpenPriceChestAt(blueprintName, chestPosition, chestRotation, chestPosition, chestRotation);
		}

		public static void OpenPriceChestAt(string blueprintName, Vector3 chestPosition, Quaternion chestRotation, Vector3 previewAnchor, Quaternion previewRotation)
		{
			//IL_00b1: 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_00be: 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)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			blueprintName = (blueprintName ?? "").Trim();
			if (string.IsNullOrWhiteSpace(blueprintName))
			{
				Message(HomesteadLocalization.Text("hs_store_blueprint_name_required"), (MessageType)2);
				return;
			}
			string yaml;
			try
			{
				yaml = ZoneBlueprintCommands.SerializeBlueprintForStore(blueprintName);
			}
			catch (Exception ex)
			{
				Message(HomesteadLocalization.Format("hs_store_blueprint_load_failed", blueprintName, ex.Message), (MessageType)2);
				return;
			}
			if (!ZoneBlueprintNetworkPayload.TryCreateBlueprintPayload(yaml, enforceUploadLimit: true, out byte[] payload, out string reason))
			{
				Message(reason, (MessageType)2);
				return;
			}
			DispatchRequest("price_chest", new ZoneBlueprintStorePriceChestRequest
			{
				Name = blueprintName,
				BlueprintEncoding = "gzip",
				BlueprintPayload = payload,
				IconPngBase64 = ZoneBlueprintVisuals.GetIconPngBase64(blueprintName),
				Target = ToTransformPayload(chestPosition, chestRotation),
				PreviewAnchor = ToTransformPayload(previewAnchor, previewRotation)
			}, localPlayer);
		}

		public static void RequestListings()
		{
			ZoneBlueprintStoreUi.RequestCurrentPage();
		}

		private static void ScheduleListingRefresh()
		{
			_pendingListingRefreshAt = Time.time + 0.25f;
		}

		private static void RunPendingListingRefresh()
		{
			if (!(_pendingListingRefreshAt < 0f) && !(Time.time < _pendingListingRefreshAt))
			{
				_pendingListingRefreshAt = -1f;
				RequestListings();
			}
		}

		public static void RequestListings(IReadOnlyList<string>? iconListingIds)
		{
			ZoneBlueprintStoreUi.RequestCurrentPage(iconListingIds);
		}

		internal static void RequestListingIcons(IReadOnlyList<string> iconListingIds)
		{
			List<string> list = iconListingIds?.Where((string id) => !string.IsNullOrWhiteSpace(id)).Distinct<string>(StringComparer.Ordinal).ToList() ?? new List<string>();
			if (list.Count != 0)
			{
				DispatchRequest("list", new ZoneBlueprintStoreListRequest
				{
					IconsOnly = true,
					Limit = 0,
					IncludeNotifications = false,
					IncludeDebugIdentity = false,
					IconListingIds = list,
					FirstIconCount = 0
				}, Player.m_localPlayer);
			}
		}

		internal static void RequestListingPage(int requestId, int offset, IReadOnlyList<string>? iconListingIds, bool showHidden, bool includeNotifications)
		{
			DispatchRequest("list", new ZoneBlueprintStoreListRequest
			{
				RequestId = requestId,
				Offset = Math.Max(0, offset),
				Limit = 6,
				ShowHidden = showHidden,
				IncludeNotifications = includeNotifications,
				IncludeDebugIdentity = BlueprintConfig.StoreDebugLogging,
				IconsOnly = false,
				IconListingIds = (iconListingIds?.Where((string id) => !string.IsNullOrWhiteSpace(id)).Distinct<string>(StringComparer.Ordinal).ToList() ?? new List<string>()),
				FirstIconCount = 6
			}, Player.m_localPlayer);
		}

		internal static void SyncHiddenListings(IReadOnlyCollection<string> hiddenListingIds)
		{
			DispatchRequest("sync_hidden", new ZoneBlueprintStoreSyncHiddenRequest
			{
				HiddenListingIds = (hiddenListingIds?.Where((string id) => !string.IsNullOrWhiteSpace(id)).Distinct<string>(StringComparer.Ordinal).ToList() ?? new List<string>())
			}, Player.m_localPlayer);
		}

		public static void RequestPreview(string listingId)
		{
			DispatchRequest("preview", new ZoneBlueprintStorePreviewRequest
			{
				ListingId = listingId
			}, Player.m_localPlayer);
		}

		public static void RequestPreviewOffer(string listingId, string offerId)
		{
			DispatchRequest("preview", new ZoneBlueprintStorePreviewRequest
			{
				ListingId = listingId,
				OfferId = offerId
			}, Player.m_localPlayer);
		}

		public static void RequestBuyAt(string listingId, Vector3 chestPosition, Quaternion chestRotation, Vector3 previewAnchor, Quaternion previewRotation)
		{
			//IL_0012: 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_001f: 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)
			DispatchRequest("buy", new ZoneBlueprintStoreBuyRequest
			{
				ListingId = listingId,
				Target = ToTransformPayload(chestPosition, chestRotation),
				PreviewAnchor = ToTransformPayload(previewAnchor, previewRotation)
			}, Player.m_localPlayer);
		}

		public static void RequestBuyAt(string listingId, string offerId, Vector3 chestPosition, Quaternion chestRotation, Vector3 previewAnchor, Quaternion previewRotation)
		{
			//IL_0019: 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_0026: 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)
			DispatchRequest("buy", new ZoneBlueprintStoreBuyRequest
			{
				ListingId = listingId,
				OfferId = offerId,
				Target = ToTransformPayload(chestPosition, chestRotation),
				PreviewAnchor = ToTransformPayload(previewAnchor, previewRotation)
			}, Player.m_localPlayer);
		}

		internal static void RequestPreviewRestore(string mode, string listingId, string blueprintName, string blueprintFile)
		{
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null))
			{
				DispatchRequest("preview_restore", new ZoneBlueprintStorePreviewRestoreRequest
				{
					Mode = mode,
					ListingId = listingId,
					Name = blueprintName,
					BlueprintFile = blueprintFile
				}, localPlayer);
			}
		}

		public static void RequestBuy(string listingId)
		{
			DispatchRequest("buy", new ZoneBlueprintStoreBuyRequest
			{
				ListingId = listingId
			}, Player.m_localPlayer);
		}

		public static void RequestWithdraw()
		{
			//IL_0019: 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 localPlayer = Player.m_localPlayer;
			ZoneBlueprintStoreWithdrawRequest zoneBlueprintStoreWithdrawRequest = new ZoneBlueprintStoreWithdrawRequest();
			if (TryGetStoreChestPlacement(localPlayer, out var position, out var rotation))
			{
				zoneBlueprintStoreWithdrawRequest.Target = ToTransformPayload(position, rotation);
			}
			DispatchRequest("withdraw", zoneBlueprintStoreWithdrawRequest, localPlayer);
		}

		public static void RequestConfirmPurchase(string listingId)
		{
			DispatchRequest("confirm", new ZoneBlueprintStoreConfirmPurchaseRequest
			{
				ListingId = listingId
			}, Player.m_localPlayer);
		}

		public static void RequestConfirmPurchase(string listingId, string offerId)
		{
			DispatchRequest("confirm", new ZoneBlueprintStoreConfirmPurchaseRequest
			{
				ListingId = listingId,
				OfferId = offerId
			}, Player.m_localPlayer);
		}

		public static void RequestConfirmListing(string listingId)
		{
			DispatchRequest("confirm_listing", new ZoneBlueprintStoreConfirmListingRequest
			{
				ListingId = listingId
			}, Player.m_localPlayer);
		}

		public static void RequestConfirmListing(string listingId, IReadOnlyList<ZoneBlueprintStorePriceItem> priceItems)
		{
			DispatchRequest("confirm_listing", new ZoneBlueprintStoreConfirmListingRequest
			{
				ListingId = listingId,
				PriceItems = priceItems.ToList()
			}, Player.m_localPlayer);
		}

		public static void RequestDelist(string listingId)
		{
			DispatchRequest("delist", new ZoneBlueprintStoreDelistRequest
			{
				ListingId = listingId
			}, Player.m_localPlayer);
		}

		public static void RequestEditListingPrice(string listingId, IReadOnlyList<ZoneBlueprintStorePriceItem> priceItems)
		{
			DispatchRequest("edit_price", new ZoneBlueprintStoreEditPriceRequest
			{
				ListingId = listingId,
				PriceItems = priceItems.ToList()
			}, Player.m_localPlayer);
		}

		public static void RequestCreateOffer(string listingId, IReadOnlyList<ZoneBlueprintStorePriceItem> priceItems)
		{
			DispatchRequest("create_offer", new ZoneBlueprintStoreCreateOfferRequest
			{
				ListingId = listingId,
				PriceItems = priceItems.ToList()
			}, Player.m_localPlayer);
		}

		public static void RequestOfferList(string listingId)
		{
			DispatchRequest("list_offers", new ZoneBlueprintStoreListOffersRequest
			{
				ListingId = listingId
			}, Player.m_localPlayer);
		}

		public static void RequestOfferDecision(string listingId, string offerId, string decision)
		{
			DispatchRequest("decide_offer", new ZoneBlueprintStoreDecideOfferRequest
			{
				ListingId = listingId,
				OfferId = offerId,
				Decision = decision
			}, Player.m_localPlayer);
		}

		public static void RequestDeleteOffer(string listingId, string offerId)
		{
			DispatchRequest("delete_offer", new ZoneBlueprintStoreDeleteOfferRequest
			{
				ListingId = listingId,
				OfferId = offerId
			}, Player.m_localPlayer);
		}

		internal static HomesteadCommandResult ConfirmPurchaseLocal(string listingId, long buyerPlayerId, string buyerName, ZoneBlueprintStoreChest chest)
		{
			return ExecuteConfirm(listingId, buyerPlayerId, buyerName, 0L, chest);
		}

		internal static HomesteadCommandResult ConfirmListingLocal(string listingId, long sellerPlayerId, ZoneBlueprintStoreChest chest, IReadOnlyList<ZoneBlueprintStorePriceItem>? priceItems = null)
		{
			return ExecuteConfirmListing(listingId, sellerPlayerId, 0L, chest, priceItems);
		}

		private static ZoneBlueprintStoreRpcEnvelope Fail(string type, string message)
		{
			return CreateEnvelope(type, new ZoneBlueprintStoreStatusResponse
			{
				Success = false,
				Message = message
			});
		}

		private static ZoneBlueprintStoreRpcEnvelope Status(string type, bool success, string message)
		{
			return CreateEnvelope(type, new ZoneBlueprintStoreStatusResponse
			{
				Success = success,
				Message = message
			});
		}

		private static ZoneBlueprintStoreRpcEnvelope StatusWithListingPatch(string type, bool success, string message, ZoneBlueprintStoreCatalog catalog, ZoneBlueprintStoreListing listing, long playerId, string platformId, bool removeListing = false)
		{
			ZoneBlueprintStoreStatusResponse zoneBlueprintStoreStatusResponse = new ZoneBlueprintStoreStatusResponse
			{
				Success = success,
				Message = message,
				ListingId = listing.ListingId,
				RemoveListing = removeListing
			};
			if (success && !removeListing)
			{
				Dictionary<string, int> dictionary = BuildOfferCounts(catalog);
				zoneBlueprintStoreStatusResponse.Listing = ToSummaryDto(listing, playerId, platformId, catalog, dictionary.TryGetValue(listing.ListingId, out var value) ? value : 0, includeDebugIdentity: false);
			}
			return CreateEnvelope(type, zoneBlueprintStoreStatusResponse);
		}

		private static ZoneBlueprintStoreListingSummaryDto ToSummaryDto(ZoneBlueprintStoreListing listing)
		{
			return ToSummaryDto(listing, 0L, "");
		}

		private static bool IsOfferBuyer(ZoneBlueprintStoreOffer offer, long playerId, string platformId)
		{
			if (offer == null || playerId == 0L)
			{
				return false;
			}
			return MatchesStoreIdentity(offer.BuyerPlayerId, offer.BuyerPlatformId, playerId, platformId);
		}

		private static bool TryGetListingAndOffer(ZoneBlueprintStoreCatalog catalog, string listingId, string offerId, out ZoneBlueprintStoreListing listing, out ZoneBlueprintStoreOffer offer, out string reason)
		{
			string listingId2 = listingId;
			string offerId2 = offerId;
			listing = catalog.Listings.FirstOrDefault((ZoneBlueprintStoreListing item) => item.Active && string.Equals(item.ListingId, listingId2, StringComparison.Ordinal));
			offer = catalog.Offers.FirstOrDefault((ZoneBlueprintStoreOffer item) => string.Equals(item.ListingId, listingId2, StringComparison.Ordinal) && string.Equals(item.OfferId, offerId2, StringComparison.Ordinal) && !string.Equals(item.Status, "Deleted", StringComparison.Ordinal));
			if (listing == null)
			{
				reason = HomesteadLocalization.Text("hs_store_listing_not_found");
				return false;
			}
			if (offer == null)
			{
				reason = HomesteadLocalization.Text("hs_store_offer_not_found");
				return false;
			}
			reason = "";
			return true;
		}

		private static bool TryGetAcceptedBuyerOffer(ZoneBlueprintStoreCatalog catalog, string listingId, string offerId, long buyerPlayerId, string buyerPlatformId, out ZoneBlueprintStoreOffer offer, out string reason)
		{
			string listingId2 = listingId;
			string offerId2 = offerId;
			offer = catalog.Offers.FirstOrDefault((ZoneBlueprintStoreOffer item) => string.Equals(item.ListingId, listingId2, StringComparison.Ordinal) && string.Equals(item.OfferId, offerId2, StringComparison.Ordinal) && !string.Equals(item.Status, "Deleted", StringComparison.Ordinal));
			if (offer == null)
			{
				reason = HomesteadLocalization.Text("hs_store_accepted_offer_not_found");
				return false;
			}
			if (!string.Equals(offer.Status, "Accepted", StringComparison.Ordinal))
			{
				reason = HomesteadLocalization.Text("hs_store_offer_not_accepted");
				return false;
			}
			if (!IsOfferBuyer(offer, buyerPlayerId, buyerPlatformId))
			{
				reason = HomesteadLocalization.Text("hs_store_offer_other_buyer");
				return false;
			}
			reason = "";
			return true;
		}

		private static ZoneBlueprintStoreOfferDto ToOfferDto(ZoneBlueprintStoreOffer offer, bool canManage, long playerId, string platformId)
		{
			List<ZoneBlueprintStorePriceItem> list = NormalizePriceItems(offer.PriceItems);
			bool flag = IsOfferBuyer(offer, playerId, platformId);
			bool flag2 = string.Equals(offer.Status, "Pending", StringComparison.Ordinal);
			return new ZoneBlueprintStoreOfferDto
			{
				OfferId = offer.OfferId,
				ListingId = offer.ListingId,
				BuyerName = offer.BuyerName,
				PriceItems = list,
				PriceText = FormatPrice(list),
				Status = offer.Status,
				CanAccept = (canManage && flag2),
				CanDecline = (canManage && !string.Equals(offer.Status, "Declined", StringComparison.Ordinal)),
				CanDelete = (canManage || flag),
				CanBuy = (flag && string.Equals(offer.Status, "Accepted", StringComparison.Ordinal))
			};
		}

		private static string CreateOfferId()
		{
			return "offer_" + DateTime.UtcNow.ToString("yyyyMMddHHmmssfff") + "_" + Guid.NewGuid().ToString("N").Substring(0, 8);
		}

		private static ZoneBlueprintStoreListingSummaryDto ToSummaryDto(ZoneBlueprintStoreListing listing, long playerId, string platformId)
		{
			ZoneBlueprintStoreCatalog catalog = ZoneBlueprintStoreDraftRepository.LoadCatalogReadOnly();
			Dictionary<string, int> dictionary = BuildOfferCounts(catalog);
			int value;
			return ToSummaryDto(listing, playerId, platformId, catalog, dictionary.TryGetValue(listing.ListingId, out value) ? value : 0, includeDebugIdentity: false);
		}

		private static ZoneBlueprintStoreListingSummaryDto ToSummaryDto(ZoneBlueprintStoreListing listing, long playerId, string platformId, ZoneBlueprintStoreCatalog catalog, int offerCount, bool includeDebugIdentity)
		{
			List<ZoneBlueprintStorePriceItem> listingPriceItems = GetListingPriceItems(listing);
			bool flag = IsStoreListingOwner(listing, playerId, platformId);
			return new ZoneBlueprintStoreListingSummaryDto
			{
				ListingId = listing.ListingId,
				Name = listing.Name,
				SellerName = listing.SellerName,
				DebugIdentity = (includeDebugIdentity ? new ZoneBlueprintStoreListingIdentityDebugDto
				{
					SellerPlayerId = listing.SellerPlayerId,
					RequesterPlayerId = playerId,
					IdentityMode = BlueprintConfig.StoreIdentityMode.ToString()
				} : null),
				PriceItems = listingPriceItems,
				PurchaseCount = listing.PurchaseCount,
				OfferCount = offerCount,
				CanDelist = flag,
				CanManage = flag
			};
		}

		private static Dictionary<string, int> BuildOfferCounts(ZoneBlueprintStoreCatalog catalog)
		{
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.Ordinal);
			foreach (ZoneBlueprintStoreOffer offer in catalog.Offers)
			{
				if (!string.IsNullOrWhiteSpace(offer.ListingId) && !string.Equals(offer.Status, "Deleted", StringComparison.OrdinalIgnoreCase))
				{
					dictionary.TryGetValue(offer.ListingId, out var value);
					dictionary[offer.ListingId] = value + 1;
				}
			}
			return dictionary;
		}

		private static bool HasWithdrawableBalance(ZoneBlueprintStoreCatalog catalog, long playerId, string platformId)
		{
			ZoneBlueprintStoreActor seller = ZoneBlueprintStoreIdentity.Actor(playerId, platformId);
			if (seller.IsValid)
			{
				return catalog.Balances.Any((ZoneBlueprintStoreBalance balance) => seller.MatchesStored(balance.SellerPlayerId, balance.SellerPlatformId, BlueprintConfig.StoreIdentityMode) && (balance.Coins > 0 || (balance.Materials?.Any((ZoneBlueprintStorePriceItem item) => item.Amount > 0) ?? false)));
			}
			return false;
		}

		private static void CreditSeller(ZoneBlueprintStoreListing listing)
		{
			ZoneBlueprintStoreCatalog catalog = ZoneBlueprintStoreDraftRepository.LoadCatalog();
			CreditSeller(catalog, listing, GetListingPriceItems(listing), incrementPurchaseCount: true);
			ZoneBlueprintStoreDraftRepository.SaveCatalog(catalog, immediate: true);
		}

		private static void CreditSeller(ZoneBlueprintStoreCatalog catalog, ZoneBlueprintStoreListing listing, IEnumerable<ZoneBlueprintStorePriceItem> paidItems, bool incrementPurchaseCount)
		{
			ZoneBlueprintStoreListing listing2 = listing;
			ZoneBlueprintStoreListing zoneBlueprintStoreListing = catalog.Listings.FirstOrDefault((ZoneBlueprintStoreListing item) => item.ListingId == listing2.ListingId);
			if (zoneBlueprintStoreListing != null)
			{
				if (incrementPurchaseCount)
				{
					zoneBlueprintStoreListing.PurchaseCount++;
				}
				listing2 = zoneBlueprintStoreListing;
			}
			ZoneBlueprintStoreActor seller = ZoneBlueprintStoreIdentity.Actor(listing2.SellerPlayerId, listing2.SellerPlatformId);
			ZoneBlueprintStoreBalance zoneBlueprintStoreBalance = catalog.Balances.FirstOrDefault((ZoneBlueprintStoreBalance item) => seller.MatchesStored(item.SellerPlayerId, item.SellerPlatformId, BlueprintConfig.StoreIdentityMode));
			if (zoneBlueprintStoreBalance == null)
			{
				zoneBlueprintStoreBalance = new ZoneBlueprintStoreBalance
				{
					SellerPlayerId = listing2.SellerPlayerId,
					SellerPlatformId = HomesteadPlayerIdentity.NormalizePlatformId(listing2.SellerPlatformId),
					SellerName = listing2.SellerName
				};
				catalog.Balances.Add(zoneBlueprintStoreBalance);
			}
			if (string.IsNullOrWhiteSpace(zoneBlueprintStoreBalance.SellerPlatformId))
			{
				zoneBlueprintStoreBalance.SellerPlatformId = HomesteadPlayerIdentity.NormalizePlatformId(listing2.SellerPlatformId);
			}
			zoneBlueprintStoreBalance.SellerName = listing2.SellerName;
			foreach (ZoneBlueprintStorePriceItem item2 in NormalizePriceItems(paidItems))
			{
				ZoneBlueprintStorePriceItem zoneBlueprintStorePriceItem = zoneBlueprintStoreBalance.Materials.FirstOrDefault((ZoneBlueprintStorePriceItem value) => value.ItemName == item2.ItemName);
				if (zoneBlueprintStorePriceItem == null)
				{
					zoneBlueprintStorePriceItem = new ZoneBlueprintStorePriceItem
					{
						ItemName = item2.ItemName,
						PrefabName = item2.PrefabName,
						DisplayName = item2.DisplayName
					};
					zoneBlueprintStoreBalance.Materials.Add(zoneBlueprintStorePriceItem);
				}
				zoneBlueprintStorePriceItem.PrefabName = (string.IsNullOrWhiteSpace(zoneBlueprintStorePriceItem.PrefabName) ? item2.PrefabName : zoneBlueprintStorePriceItem.PrefabName);
				zoneBlueprintStorePriceItem.DisplayName = (string.IsNullOrWhiteSpace(zoneBlueprintStorePriceItem.DisplayName) ? item2.DisplayName : zoneBlueprintStorePriceItem.DisplayName);
				zoneBlueprintStorePriceItem.Amount += item2.Amount;
			}
			zoneBlueprintStoreBalance.Materials = NormalizePriceItems(zoneBlueprintStoreBalance.Materials);
		}

		private static bool TryResolveRequester(Player? player, long sender, out long playerId, out string playerName, out Vector3 position, out Quaternion rotation, out string reason)
		{
			//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)
			//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_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_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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_00fd: 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_0129: 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_0162: 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_0174: 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)
			playerId = 0L;
			playerName = HomesteadLocalization.Text("hs_common_unknown");
			position = Vector3.zero;
			rotation = Quaternion.identity;
			reason = "";
			Quaternion rotation2;
			if ((Object)(object)player != (Object)null)
			{
				playerId = player.GetPlayerID();
				playerName = player.GetPlayerName();
				position = ((Component)player).transform.position;
				rotation2 = ((Component)player).transform.rotation;
				rotation = Quaternion.Euler(0f, ((Quaternion)(ref rotation2)).eulerAngles.y, 0f);
				return playerId != 0;
			}
			if ((Object)(object)ZNet.instance == (Object)null || ZDOMan.instance == null)
			{
				reason = HomesteadLocalization.Text("hs_common_world_not_ready");
				return false;
			}
			ZNetPeer peer = ZNet.instance.GetPeer(sender);
			if (peer == null || !peer.IsReady())
			{
				reason = HomesteadLocalization.Text("hs_common_player_not_ready");
				return false;
			}
			playerName = (string.IsNullOrWhiteSpace(peer.m_playerName) ? HomesteadLocalization.Text("hs_common_unknown") : peer.m_playerName);
			position = peer.m_refPos;
			if (((ZDOID)(ref peer.m_characterID)).IsNone())
			{
				reason = HomesteadLocalization.Text("hs_store_character_missing");
				return false;
			}
			ZDO zDO = ZDOMan.instance.GetZDO(peer.m_characterID);
			if (zDO == null)
			{
				reason = HomesteadLocalization.Text("hs_store_character_missing");
				return false;
			}
			playerId = zDO.GetLong(ZDOVars.s_playerID, 0L);
			rotation2 = zDO.GetRotation();
			rotation = Quaternion.Euler(0f, ((Quaternion)(ref rotation2)).eulerAngles.y, 0f);
			if (playerId == 0L)
			{
				reason = HomesteadLocalization.Text("hs_dismantle_playerid_missing");
				return false;
			}
			return true;
		}

		private static string ResolveRequesterPlatformId(Player? player, long sender, long playerId)
		{
			return HomesteadPlayerIdentity.ResolvePlatformId(player, sender, playerId);
		}

		private static ZoneBlueprintStoreActor ResolveRequesterActor(Player? player, long sender, long playerId)
		{
			return ZoneBlueprintStoreIdentity.Actor(playerId, ResolveRequesterPlatformId(player, sender, playerId));
		}

		private static bool CheckStoreListingLimit(ZoneBlueprintStoreCatalog catalog, long sellerPlayerId, string sellerPlatformId, out string reason)
		{
			string sellerPlatformId2 = sellerPlatformId;
			int maxListingsPerSteamId = BlueprintConfig.StoreSettings.MaxListingsPerSteamId;
			int num = catalog.Listings.Count((ZoneBlueprintStoreListing listing) => listing.Active && (string.Equals(listing.SellerPlatformId, sellerPlatformId2, StringComparison.Ordinal) || (string.IsNullOrWhiteSpace(listing.SellerPlatformId) && listing.SellerPlayerId == sellerPlayerId)));
			if (num >= maxListingsPerSteamId)
			{
				reason = HomesteadLocalization.Format("hs_store_listing_limit_reached", num, maxListingsPerSteamId);
				return false;
			}
			reason = "";
			return true;
		}

		private static bool IsStoreListingOwner(ZoneBlueprintStoreListing listing, long playerId, string platformId)
		{
			return IsStoreListingOwner(listing, ZoneBlueprintStoreIdentity.Actor(playerId, platformId));
		}

		private static bool IsStoreListingOwner(ZoneBlueprintStoreListing listing, ZoneBlueprintStoreActor actor)
		{
			if (listing == null || !actor.IsValid)
			{
				return false;
			}
			return actor.MatchesStored(listing.SellerPlayerId, listing.SellerPlatformId, BlueprintConfig.StoreIdentityMode);
		}

		private static bool MatchesStoreIdentity(long storedPlayerId, string storedPlatformId, long playerId, string platformId)
		{
			return ZoneBlueprintStoreIdentity.Actor(playerId, platformId).MatchesStored(storedPlayerId, storedPlatformId, BlueprintConfig.StoreIdentityMode);
		}

		private static HashSet<string> GetHiddenListingIds(long playerId, string platformId)
		{
			string text = HiddenStateKey(playerId, platformId);
			if (string.IsNullOrWhiteSpace(text) || !HiddenListingIdsByRequester.TryGetValue(text, out HashSet<string> value))
			{
				return new HashSet<string>();
			}
			return value;
		}

		private static void SetHiddenListingIds(long playerId, string platformId, IEnumerable<string>? listingIds)
		{
			string text = HiddenStateKey(playerId, platformId);
			if (!string.IsNullOrWhiteSpace(text))
			{
				HashSet<string> value = listingIds?.Where((string id) => !string.IsNullOrWhiteSpace(id)).ToHashSet<string>(StringComparer.Ordinal) ?? new HashSet<string>();
				HiddenListingIdsByRequester[text] = value;
			}
		}

		private static string HiddenStateKey(long playerId, string platformId)
		{
			return ZoneBlueprintStoreIdentity.HiddenStateKey(ZoneBlueprintStoreIdentity.Actor(playerId, platformId), BlueprintConfig.StoreIdentityMode);
		}

		private static void RunOrphanDraftSweepIfDue()
		{
			if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer() && ZDOMan.instance != null && !(Time.time < _nextOrphanDraftSweep))
			{
				_nextOrphanDraftSweep = Time.time + 300f;
				TimeSpan orphanDraftGraceTime = GetOrphanDraftGraceTime();
				if (!(orphanDraftGraceTime <= TimeSpan.Zero) && ZoneBlueprintStoreDraftRepository.HasOrphanDraftCandidates(orphanDraftGraceTime) && TryGetLiveDraftFiles(out HashSet<string> files))
				{
					ZoneBlueprintStoreDraftRepository.SweepOrphanDrafts(files, orphanDraftGraceTime);
				}
			}
		}

		private static bool TryGetLiveDraftFiles(out HashSet<string> files)
		{
			if (ZoneBlueprintChestZdoRegistry.TryGetLiveOwnedDraftFiles(out HashSet<string> files2))
			{
				files = files2;
				return true;
			}
			files = new HashSet<string>();
			return false;
		}

		private static TimeSpan GetOrphanDraftGraceTime()
		{
			int chestTimeoutMinutes = BlueprintConfig.ChestTimeoutMinutes;
			if (chestTimeoutMinutes > 0)
			{
				return TimeSpan.FromMinutes(chestTimeoutMinutes);
			}
			return TimeSpan.Zero;
		}

		private static void ResetNotificationSession()
		{
			_nextNotificationPoll = 0f;
			_pendingRecentNotificationRequest = -1f;
		}

		public static void RequestReadNotifications(IReadOnlyList<string> notificationIds)
		{
			if (notificationIds.Count != 0)
			{
				DispatchRequest("read_notifications", new ZoneBlueprintStoreReadNotificationsRequest
				{
					NotificationIds = notificationIds.ToList()
				}, Player.m_localPlayer);
			}
		}

		public static void RequestNotifications()
		{
			DispatchRequest("get_notifications", new ZoneBlueprintStoreGetNotificationsRequest(), Player.m_localPlayer);
		}

		public static void RequestRecentNotifications()
		{
			DispatchRequest("recent_notifications", new ZoneBlueprintStoreRecentNotificationsRequest
			{
				Limit = 32
			}, Player.m_localPlayer);
		}

		private static void ScheduleRecentNotifications()
		{
			_pendingRecentNotificationRequest = Time.time + 1f;
		}

		private static void RequestPendingRecentNotifications()
		{
			if (!(_pendingRecentNotificationRequest < 0f) && !(Time.time < _pendingRecentNotificationRequest))
			{
				_pendingRecentNotificationRequest = -1f;
				RequestRecentNotifications();
			}
		}

		private static void RequestNotificationsIfDue()
		{
			if (!((Object)(object)Player.m_localPlayer == (Object)null) && !((Object)(object)ZNet.instance == (Object)null) && ZRoutedRpc.instance != null)
			{
				int storeNotificationPollSeconds = BlueprintConfig.StoreNotificationPollSeconds;
				if (storeNotificationPollSeconds > 0 && !(Time.time < _nextNotificationPoll))
				{
					_nextNotificationPoll = Time.time + (float)storeNotificationPollSeconds;
					RequestNotifications();
				}
			}
		}

		private static bool TryHandleNotificationResponse(ZoneBlueprintStoreRpcEnvelope response)
		{
			if (response.Type == "notify")
			{
				List<ZoneBlueprintStoreNotificationDto> notifications = ReadPayload<ZoneBlueprintStoreNotificationResponse>(response).Notifications;
				ZoneBlueprintStoreNotificationsUi.AddNotifications(notifications);
				UpdateWithdrawHintFromNotifications(notifications);
				return true;
			}
			if (response.Type == "get_notifications")
			{
				ZoneBlueprintStoreNotificationsUi.AddNotifications(ReadPayload<ZoneBlueprintStoreNotificationResponse>(response).Notifications);
				return true;
			}
			if (response.Type == "recent_notifications")
			{
				ZoneBlueprintStoreNotificationsUi.SetNotifications(ReadPayload<ZoneBlueprintStoreNotificationResponse>(response).Notifications);
				return true;
			}
			return response.Type == "read_notifications";
		}

		private static void UpdateWithdrawHintFromNotifications(IEnumerable<ZoneBlueprintStoreNotificationDto> notifications)
		{
			if (notifications.Any((ZoneBlueprintStoreNotificationDto notification) => string.Equals(notification.Type, "BlueprintPurchased", StringComparison.Ordinal)))
			{
				ZoneBlueprintStoreUi.SetWithdrawableBalance(hasBalance: true);
			}
		}

		private static ZoneBlueprintStoreNotification AddStoreNotification(ZoneBlueprintStoreCatalog catalog, long recipientPlayerId, string recipientPlatformId, string recipientName, string actorName, ZoneBlueprintStoreListing listing, ZoneBlueprintStoreOffer offer, string type, string message)
		{
			if (catalog.Notifications == null)
			{
				List<ZoneBlueprintStoreNotification> list2 = (catalog.Notifications = new List<ZoneBlueprintStoreNotification>());
			}
			ZoneBlueprintStoreNotification zoneBlueprintStoreNotification = new ZoneBlueprintStoreNotification
			{
				NotificationId = CreateNotificationId(),
				Type = type,
				RecipientPlayerId = recipientPlayerId,
				RecipientPlatformId = HomesteadPlayerIdentity.NormalizePlatformId(recipientPlatformId),
				RecipientName = (recipientName ?? ""),
				ActorName = (actorName ?? ""),
				ListingId = listing.ListingId,
				ListingName = listing.Name,
				OfferId = offer.OfferId,
				Message = message,
				CreatedAt = HomesteadTimestamp.Now(),
				Read = false
			};
			catalog.Notifications.Add(zoneBlueprintStoreNotification);
			PruneStoreNotifications(catalog);
			return zoneBlueprintStoreNotification;
		}

		private static ZoneBlueprintStoreNotification AddOfferReceivedNotification(ZoneBlueprintStoreCatalog catalog, ZoneBlueprintStoreListing listing, ZoneBlueprintStoreOffer offer, string buyerName, IEnumerable<ZoneBlueprintStorePriceItem> priceItems, bool updated)
		{
			string actorName = NotificationActorName(buyerName);
			return AddStoreNotification(catalog, listing.SellerPlayerId, listing.SellerPlatformId, listing.SellerName, actorName, listing, offer, "OfferReceived", FormatActorNotification(updated ? "hs_store_notification_offer_updated" : "hs_store_notification_offer_received", updated ? "hs_store_notification_offer_updated_anonymous" : "hs_store_notification_offer_received_anonymous", buyerName, listing.Name, FormatPrice(priceItems)));
		}

		private static ZoneBlueprintStoreNotification AddOfferDecisionNotification(ZoneBlueprintStoreCatalog catalog, ZoneBlueprintStoreListing listing, ZoneBlueprintStoreOffer offer, bool accepted)
		{
			string actorName = NotificationActorName(listing.SellerName);
			return AddStoreNotification(catalog, offer.BuyerPlayerId, offer.BuyerPlatformId, offer.BuyerName, actorName, listing, offer, accepted ? "OfferAccepted" : "OfferDeclined", accepted ? FormatActorNotification("hs_store_notification_offer_accepted", "hs_store_notification_offer_accepted_anonymous", listing.SellerName, listing.Name, FormatPrice(offer.PriceItems)) : FormatActorNotification("hs_store_notification_offer_declined", "hs_store_notification_offer_declined_anonymous", listing.SellerName, listing.Name));
		}

		private static string NotificationActorName(string actorName)
		{
			if (BlueprintConfig.StoreAnonymousNotifications)
			{
				return HomesteadLocalization.Text("hs_store_notification_anonymous");
			}
			if (!string.IsNullOrWhiteSpace(actorName))
			{
				return actorName;
			}
			return HomesteadLocalization.Text("hs_common_unknown");
		}

		private static string FormatActorNotification(string normalToken, string anonymousToken, string actorName, params object[] values)
		{
			if (BlueprintConfig.StoreAnonymousNotifications)
			{
				return HomesteadLocalization.Format(anonymousToken, values);
			}
			object[] array = new object[values.Length + 1];
			array[0] = NotificationActorName(actorName);
			Array.Copy(values, 0, array, 1, values.Length);
			return HomesteadLocalization.Format(normalToken, array);
		}

		private static ZoneBlueprintStoreNotification AddPublicNewListingNotification(ZoneBlueprintStoreCatalog catalog, string actorName, ZoneBlueprintStoreListing listing)
		{
			string actorName2 = NotificationActorName(actorName);
			if (catalog.Notifications == null)
			{
				List<ZoneBlueprintStoreNotification> list2 = (catalog.Notifications = new List<ZoneBlueprintStoreNotification>());
			}
			ZoneBlueprintStoreNotification zoneBlueprintStoreNotification = new ZoneBlueprintStoreNotification();
			zoneBlueprintStoreNotification.NotificationId = CreateNotificationId();
			zoneBlueprintStoreNotification.Type = "NewListing";
			zoneBlueprintStoreNotification.RecipientPlayerId = 0L;
			zoneBlueprintStoreNotification.RecipientPlatformId = "";
			zoneBlueprintStoreNotification.RecipientName = "";
			zoneBlueprintStoreNotification.ActorName = actorName2;
			zoneBlueprintStoreNotification.ListingId = listing.ListingId;
			zoneBlueprintStoreNotification.ListingName = listing.Name;
			zoneBlueprintStoreNotification.OfferId = "";
			zoneBlueprintStoreNotification.Message = FormatActorNotification("hs_store_notification_new_listing", "hs_store_notification_new_listing_anonymous", actorName, listing.Name, FormatPrice(GetListingPriceItems(listing)));
			zoneBlueprintStoreNotification.CreatedAt = HomesteadTimestamp.Now();
			zoneBlueprintStoreNotification.Read = false;
			ZoneBlueprintStoreNotification zoneBlueprintStoreNotification2 = zoneBlueprintStoreNotification;
			catalog.Notifications.Add(zoneBlueprintStoreNotification2);
			PruneStoreNotifications(catalog);
			return zoneBlueprintStoreNotification2;
		}

		private static ZoneBlueprintStoreNotification AddPurchaseNotification(ZoneBlueprintStoreCatalog catalog, ZoneBlueprintStoreListing listing, string buyerName, IEnumerable<ZoneBlueprintStorePriceItem> priceItems, string offerId)
		{
			string actorName = NotificationActorName(buyerName);
			if (catalog.Notifications == null)
			{
				List<ZoneBlueprintStoreNotification> list2 = (catalog.Notifications = new List<ZoneBlueprintStoreNotification>());
			}
			ZoneBlueprintStoreNotification zoneBlueprintStoreNotification = new ZoneBlueprintStoreNotification();
			zoneBlueprintStoreNotification.NotificationId = CreateNotificationId();
			zoneBlueprintStoreNotification.Type = "BlueprintPurchased";
			zoneBlueprintStoreNotification.RecipientPlayerId = listing.SellerPlayerId;
			zoneBlueprintStoreNotification.RecipientPlatformId = HomesteadPlayerIdentity.NormalizePlatformId(listing.SellerPlatformId);
			zoneBlueprintStoreNotification.RecipientName = listing.SellerName ?? "";
			zoneBlueprintStoreNotification.ActorName = actorName;
			zoneBlueprintStoreNotification.ListingId = listing.ListingId;
			zoneBlueprintStoreNotification.ListingName = listing.Name;
			zoneBlueprintStoreNotification.OfferId = offerId ?? "";
			zoneBlueprintStoreNotification.Message = FormatActorNotification("hs_store_notification_purchased", "hs_store_notification_purchased_anonymous", buyerName, listing.Name, FormatPrice(priceItems));
			zoneBlueprintStoreNotification.CreatedAt = HomesteadTimestamp.Now();
			zoneBlueprintStoreNotification.Read = false;
			ZoneBlueprintStoreNotification zoneBlueprintStoreNotification2 = zoneBlueprintStoreNotification;
			catalog.Notifications.Add(zoneBlueprintStoreNotification2);
			PruneStoreNotifications(catalog);
			return zoneBlueprintStoreNotification2;
		}

		private static void PruneStoreNotifications(ZoneBlueprintStoreCatalog catalog)
		{
			if (catalog.Notifications == null)
			{
				List<ZoneBlueprintStoreNotification> list2 = (catalog.Notifications = new List<ZoneBlueprintStoreNotification>());
			}
			foreach (ZoneBlueprintStoreNotification notification in catalog.Notifications)
			{
				PruneNotificationReadMarkers(notification);
			}
			if (catalog.Notifications.Count > 1024)
			{
				catalog.Notifications = catalog.Notifications.OrderByDescending<ZoneBlueprintStoreNotification, string>((ZoneBlueprintStoreNotification notification) => notification.CreatedAt, StringComparer.Ordinal).ThenByDescending<ZoneBlueprintStoreNotification, string>((ZoneBlueprintStoreNotification notification) => notification.NotificationId, StringComparer.Ordinal).Take(1024)
					.ToList();
			}
		}

		private static void PruneNotificationReadMarkers(ZoneBlueprintStoreNotification notification)
		{
			if (notification.ReadByPlatformIds != null && notification.ReadByPlatformIds.Count > 1024)
			{
				notification.ReadByPlatformIds.RemoveRange(0, notification.ReadByPlatformIds.Count - 1024);
			}
			if (notification.ReadByPlayerIds != null && notification.ReadByPlayerIds.Count > 1024)
			{
				notification.ReadByPlayerIds.RemoveRange(0, notification.ReadByPlayerIds.Count - 1024);
			}
		}

		private static void PushLatestNotification(ZoneBlueprintStoreCatalog catalog)
		{
			ZoneBlueprintStoreNotification zoneBlueprintStoreNotification = catalog.Notifications?.Where((ZoneBlueprintStoreNotification item) => !item.Read).OrderByDescending<ZoneBlueprintStoreNotification, string>((ZoneBlueprintStoreNotification item) => item.CreatedAt, StringComparer.Ordinal).FirstOrDefault();
			if (zoneBlueprintStoreNotification != null)
			{
				PushNotification(zoneBlueprintStoreNotification);
			}
		}

		private static void PushNotification(ZoneBlueprintStoreNotification notification)
		{
			ZoneBlueprintStoreNotificationResponse payload = new ZoneBlueprintStoreNotificationResponse
			{
				Notifications = new List<ZoneBlueprintStoreNotificationDto>(1) { ToNotificationDto(notification) }
			};
			ZoneBlueprintStoreRpcEnvelope zoneBlueprintStoreRpcEnvelope = CreateEnvelope("notify", payload);
			bool flag = IsPublicNotification(notification);
			if ((TryHandleLocalNotification(notification, zoneBlueprintStoreRpcEnvelope) && !flag) || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || ZRoutedRpc.instance == null)
			{
				return;
			}
			foreach (ZNetPeer peer in ZNet.instance.GetPeers())
			{
				if (IsPeerNotificationRecipient(peer, notification))
				{
					SendResponse(peer.m_uid, zoneBlueprintStoreRpcEnvelope);
					if (!flag)
					{
						break;
					}
				}
			}
		}

		private static bool TryHandleLocalNotification(ZoneBlueprintStoreNotification notification, ZoneBlueprintStoreRpcEnvelope envelope)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return false;
			}
			long playerID = localPlayer.GetPlayerID();
			string platformId = HomesteadPlayerIdentity.ResolveLocalPlatformId(playerID);
			if (!IsNotificationRecipient(notification, playerID, platformId))
			{
				return false;
			}
			HandleResponse(envelope);
			return true;
		}

		private static bool IsPeerNotificationRecipient(ZNetPeer peer, ZoneBlueprintStoreNotification notification)
		{
			if (!HomesteadPlayerIdentity.TryGetPeerActivity(peer, out string platformId, out long playerId, out string _))
			{
				return false;
			}
			return IsNotificationRecipient(notification, playerId, platformId);
		}

		private static List<ZoneBlueprintStoreNotificationDto> GetUnreadNotifications(ZoneBlueprintStoreCatalog catalog, long playerId, string platformId)
		{
			string platformId2 = platformId;
			if (catalog.Notifications == null)
			{
				List<ZoneBlueprintStoreNotification> list2 = (catalog.Notifications = new List<ZoneBlueprintStoreNotification>());
			}
			return (from notification in catalog.Notifications.Where((ZoneBlueprintStoreNotification notification) => !IsNotificationRead(notification, playerId, platformId2) && IsNotificationRecipient(notification, playerId, platformId2)).OrderByDescending<ZoneBlueprintStoreNotification, string>((ZoneBlueprintStoreNotification notification) => notification.CreatedAt, StringComparer.Ordinal).Take(32)
				select ToNotificationDto(notification, playerId, platformId2)).ToList();
		}

		private static List<ZoneBlueprintStoreNotificationDto> GetRecentNotifications(ZoneBlueprintStoreCatalog catalog, long playerId, string platformId, int limit)
		{
			string platformId2 = platformId;
			if (catalog.Notifications == null)
			{
				List<ZoneBlueprintStoreNotification> list2 = (catalog.Notifications = new List<ZoneBlueprintStoreNotification>());
			}
			int count = Mathf.Clamp(limit, 1, 64);
			return (from notification in catalog.Notifications.Where((ZoneBlueprintStoreNotification notification) => IsNotificationRecipient(notification, playerId, platformId2)).OrderByDescending<ZoneBlueprintStoreNotification, string>((ZoneBlueprintStoreNotification notification) => notification.CreatedAt, StringComparer.Ordinal).Take(count)
				select ToNotificationDto(notification, playerId, platformId2)).ToList();
		}

		private static bool IsNotificationRecipient(ZoneBlueprintStoreNotification notification, long playerId, string platformId)
		{
			if (notification == null || playerId == 0L)
			{
				return false;
			}
			if (IsPublicNotification(notification))
			{
				return true;
			}
			return MatchesStoreIdentity(notification.RecipientPlayerId, notification.RecipientPlatformId, playerId, platformId);
		}

		private static bool IsPublicNotification(ZoneBlueprintStoreNotification notification)
		{
			if (notification != null && string.Equals(notification.Type, "NewListing", StringComparison.Ordinal) && string.IsNullOrWhiteSpace(notification.RecipientPlatformId))
			{
				return notification.RecipientPlayerId == 0;
			}
			return false;
		}

		private static bool IsNotificationRead(ZoneBlueprintStoreNotification notification, long playerId, string platformId)
		{
			if (!IsPublicNotification(notification))
			{
				return notification.Read;
			}
			if (BlueprintConfig.StoreIdentityMode == BlueprintStoreIdentityMode.PlayerId)
			{
				return notification.ReadByPlayerIds?.Contains(playerId) ?? false;
			}
			string normalizedPlatformId = HomesteadPlayerIdentity.NormalizePlatformId(platformId);
			if (!string.IsNullOrWhiteSpace(normalizedPlatformId))
			{
				List<string> readByPlatformIds = notification.ReadByPlatformIds;
				if (readByPlatformIds != null && readByPlatformIds.Any((string id) => string.Equals(HomesteadPlayerIdentity.NormalizePlatformId(id), normalizedPlatformId, StringComparison.Ordinal)))
				{
					return true;
				}
			}
			if (string.IsNullOrWhiteSpace(normalizedPlatformId))
			{
				return notification.ReadByPlayerIds?.Contains(playerId) ?? false;
			}
			return false;
		}

		private static void MarkNotificationRead(ZoneBlueprintStoreNotification notification, long playerId, string platformId)
		{
			if (!IsPublicNotification(notification))
			{
				notification.Read = true;
				return;
			}
			ZoneBlueprintStoreNotification zoneBlueprintStoreNotification;
			if (BlueprintConfig.StoreIdentityMode == BlueprintStoreIdentityMode.SteamId)
			{
				string normalizedPlatformId = HomesteadPlayerIdentity.NormalizePlatformId(platformId);
				if (!string.IsNullOrWhiteSpace(normalizedPlatformId))
				{
					zoneBlueprintStoreNotification = notification;
					if (zoneBlueprintStoreNotification.ReadByPlatformIds == null)
					{
						List<string> list2 = (zoneBlueprintStoreNotification.ReadByPlatformIds = new List<string>());
					}
					if (!notification.ReadByPlatformIds.Any((string id) => string.Equals(HomesteadPlayerIdentity.NormalizePlatformId(id), normalizedPlatformId, StringComparison.Ordinal)))
					{
						notification.ReadByPlatformIds.Add(normalizedPlatformId);
					}
					return;
				}
			}
			zoneBlueprintStoreNotification = notification;
			if (zoneBlueprintStoreNotification.ReadByPlayerIds == null)
			{
				List<long> list4 = (zoneBlueprintStoreNotification.ReadByPlayerIds = new List<long>());
			}
			if (playerId != 0L && !notification.ReadByPlayerIds.Contains(playerId))
			{
				notification.ReadByPlayerIds.Add(playerId);
			}
		}

		private static ZoneBlueprintStoreNotificationDto ToNotificationDto(ZoneBlueprintStoreNotification notification)
		{
			return ToNotificationDto(notification, 0L, "");
		}

		private static ZoneBlueprintStoreNotificationDto ToNotificationDto(ZoneBlueprintStoreNotification notification, long playerId, string platformId)
		{
			return new ZoneBlueprintStoreNotificationDto
			{
				NotificationId = notification.NotificationId,
				Type = notification.Type,
				ActorName = notification.ActorName,
				ListingId = notification.ListingId,
				ListingName = notification.ListingName,
				OfferId = notification.OfferId,
				Message = notification.Message,
				CreatedAt = notification.CreatedAt,
				Read = ((playerId != 0L) ? IsNotificationRead(notification, playerId, platformId) : notification.Read)
			};
		}

		private static string CreateNotificationId()
		{
			return "note_" + DateTime.UtcNow.ToString("yyyyMMddHHmmssfff") + "_" + Guid.NewGuid().ToString("N").Substring(0, 8);
		}

		private static bool TryGetStoreChestPlacement(Player? player, out Vector3 position, out Quaternion rotation)
		{
			//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)
			//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_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_0044: 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_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_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			position = Vector3.zero;
			rotation = Quaternion.identity;
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			rotation = GetAimYawRotation(player);
			if (ZoneToolAim.TryGetAimPoint(player, 128f, out position))
			{
				return true;
			}
			position = ((Component)player).transform.position + rotation * new Vector3(0f, 0f, 2.2f);
			position.y = SampleGroundY(position.x, position.z, ((Component)player).transform.position.y);
			return true;
		}

		private static Quaternion GetAimYawRotation(Player player)
		{
			//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_005a: 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_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			Camera mainCamera = Utils.GetMainCamera();
			if ((Object)(object)mainCamera != (Object)null)
			{
				Vector3 forward = ((Component)mainCamera).transform.forward;
				forward.y = 0f;
				if (((Vector3)(ref forward)).sqrMagnitude > 0.0001f)
				{
					return Quaternion.LookRotation(((Vector3)(ref forward)).normalized, Vector3.up);
				}
			}
			Quaternion rotation = ((Component)player).transform.rotation;
			return Quaternion.Euler(0f, ((Quaternion)(ref rotation)).eulerAngles.y, 0f);
		}

		private static bool TryReadOptionalStoreChestTarget(ZoneBlueprintStoreTransformPayload? payload, Vector3 requesterPosition, Quaternion fallbackRotation, out bool hasTarget, out Vector3 position, out Quaternion rotation, out string reason)
		{
			//IL_0005: 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_0011: 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_0035: 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_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0081: 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)
			hasTarget = false;
			position = Vector3.zero;
			rotation = fallbackRotation;
			reason = "";
			if (payload == null)
			{
				return true;
			}
			hasTarget = true;
			if (!TryReadTransform(payload, out position, out rotation) || !IsFinite(position) || !IsFinite(rotation))
			{
				reason = "Blueprint store chest target is invalid.";
				return false;
			}
			if (!IsWithinHorizontalDistance(requesterPosition, position, 136f))
			{
				reason = "Blueprint store chest target is too far from you.";
				return false;
			}
			rotation = SanitizeYawRotation(rotation, fallbackRotation);
			return true;
		}

		private static bool TryReadOptionalStorePreviewAnchor(ZoneBlueprintStoreTransformPayload? payload, Vector3 requesterPosition, Vector3 fallbackPosition, Quaternion fallbackRotation, out Vector3 position, out Quaternion rotation, out string reason)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: 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_000b: 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_0039: 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_0052: 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_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: 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)
			position = fallbackPosition;
			rotation = fallbackRotation;
			reason = "";
			if (payload == null)
			{
				return true;
			}
			if (!TryReadTransform(payload, out position, out rotation) || !IsFinite(position) || !IsFinite(rotation))
			{
				reason = "Blueprint store preview anchor is invalid.";
				return false;
			}
			if (!IsWithinHorizontalDistance(requesterPosition, position, 160f) || Mathf.Abs(position.y - requesterPosition.y) > 64f)
			{
				reason = "Blueprint store preview anchor is too far from you.";
				return false;
			}
			rotation = SanitizeYawRotation(rotation, fallbackRotation);
			return true;
		}

		private static bool IsWithinHorizontalDistance(Vector3 origin, Vector3 target, float maxDistance)
		{
			//IL_0000: 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)
			//IL_000d: 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)
			float num = target.x - origin.x;
			float num2 = target.z - origin.z;
			return num * num + num2 * num2 <= maxDistance * maxDistance;
		}

		private static Quaternion SanitizeYawRotation(Quaternion rotation, Quaternion fallback)
		{
			//IL_0000: 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_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_0015: 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_0023: 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_0037: 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_0050: 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_006a: 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)
			if (!IsFinite(rotation) || rotation.x * rotation.x + rotation.y * rotation.y + rotation.z * rotation.z + rotation.w * rotation.w < 0.0001f)
			{
				return fallback;
			}
			Vector3 eulerAngles = ((Quaternion)(ref rotation)).eulerAngles;
			if (!IsFinite(eulerAngles))
			{
				return fallback;
			}
			return Quaternion.Euler(0f, eulerAngles.y, 0f);
		}

		private static ZoneBlueprintStoreTransformPayload ToTransformPayload(Vector3 position, Quaternion rotation)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			return new ZoneBlueprintStoreTransformPayload
			{
				Pos = ToArray(position),
				Rot = ToArray(rotation)
			};
		}

		private static bool TryReadTransform(ZoneBlueprintStoreTransformPayload? payload, out Vector3 position, out Quaternion rotation)
		{
			//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)
			//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_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			position = Vector3.zero;
			rotation = Quaternion.identity;
			if (payload == null || payload.Pos == null || payload.Rot == null || payload.Pos.Length < 3 || payload.Rot.Length < 4)
			{
				return false;
			}
			position = new Vector3(payload.Pos[0], payload.Pos[1], payload.Pos[2]);
			rotation = new Quaternion(payload.Rot[0], payload.Rot[1], payload.Rot[2], payload.Rot[3]);
			return true;
		}

		private static bool IsFinite(Vector3 value)
		{
			//IL_0000: 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_001a: Unknown result type (might be due to invalid IL or missing references)
			if (IsFinite(value.x) && IsFinite(value.y))
			{
				return IsFinite(value.z);
			}
			return false;
		}

		private static bool IsFinite(Quaternion value)
		{
			//IL_0000: 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_001a: 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)
			if (IsFinite(value.x) && IsFinite(value.y) && IsFinite(value.z))
			{
				return IsFinite(value.w);
			}
			return false;
		}

		private static bool IsFinite(float value)
		{
			if (!float.IsNaN(value))
			{
				return !float.IsInfinity(value);
			}
			return false;
		}

		private static float[] ToArray(Vector3 value)
		{
			//IL_0008: 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_001a: Unknown result type (might be due to invalid IL or missing references)
			return new float[3] { value.x, value.y, value.z };
		}

		private static float[] ToArray(Quaternion value)
		{
			//IL_0008: 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_001a: 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)
			return new float[4] { value.x, value.y, value.z, value.w };
		}

		internal static List<ZoneBlueprintStorePriceItem> GetListingPriceItems(ZoneBlueprintStoreListing listing)
		{
			return NormalizePriceItems(listing.PriceItems);
		}

		internal static List<ZoneBlueprintStorePriceItem> NormalizePriceItems(IEnumerable<ZoneBlueprintStorePriceItem> items)
		{
			return ZoneMaterialEscrow.ToPriceItems(ZoneMaterialEscrow.ToRequirements(items));
		}

		internal static bool TryResolvePriceItem(string token, int amount, out ZoneBlueprintStorePriceItem item, out string reason)
		{
			item = new ZoneBlueprintStorePriceItem();
			reason = "";
			token = (token ?? "").Trim();
			if (string.IsNullOrWhiteSpace(token))
			{
				reason = HomesteadLocalization.Text("hs_store_item_required_short");
				return false;
			}
			if (amount <= 0)
			{
				reason = HomesteadLocalization.Text("hs_store_amount_required");
				return false;
			}
			GameObject val = FindItemPrefab(token) ?? FindItemPrefabByDisplayName(token);
			ItemDrop val2 = (Object.op_Implicit((Object)(object)val) ? val.GetComponent<ItemDrop>() : null);
			if (!Object.op_Implicit((Object)(object)val) || (Object)(object)val2 == (Object)null)
			{
				reason = HomesteadLocalization.Format("hs_store_unknown_item", token);
				return false;
			}
			item = new ZoneBlueprintStorePriceItem
			{
				ItemName = val2.m_itemData.m_shared.m_name,
				PrefabName = Utils.GetPrefabName(val),
				DisplayName = val2.m_itemData.m_shared.m_name,
				Amount = amount
			};
			return true;
		}

		internal static bool TryValidatePriceItems(IEnumerable<ZoneBlueprintStorePriceItem> source, out List<ZoneBlueprintStorePriceItem> priceItems, out string reason)
		{
			priceItems = new List<ZoneBlueprintStorePriceItem>();
			reason = "";
			List<ZoneBlueprintStorePriceItem> list = NormalizePriceItems(source);
			if (list.Count == 0)
			{
				reason = HomesteadLocalization.Text("hs_store_price_required");
				return false;
			}
			if (list.Count > 8)
			{
				reason = HomesteadLocalization.Format("hs_store_price_too_many_types", 8);
				return false;
			}
			foreach (ZoneBlueprintStorePriceItem item2 in list)
			{
				if (!TryResolvePriceItem(string.IsNullOrWhiteSpace(item2.PrefabName) ? item2.ItemName : item2.PrefabName, item2.Amount, out ZoneBlueprintStorePriceItem item, out reason))
				{
					return false;
				}
				priceItems.Add(item);
			}
			return true;
		}

		internal static string FormatPrice(IEnumerable<ZoneBlueprintStorePriceItem> items)
		{
			List<ZoneBlueprintStorePriceItem> list = NormalizePriceItems(items);
			if (list.Count != 0)
			{
				return string.Join(", ", list.Select((ZoneBlueprintStorePriceItem item) => $"{Localize(item.DisplayName)} x{item.Amount}"));
			}
			return HomesteadLocalization.Text("hs_store_no_price");
		}

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

		private static string FormatBalance(int coins, IEnumerable<ZoneBlueprintStorePriceItem> items)
		{
			List<string> list = new List<string>();
			if (coins > 0)
			{
				list.Add($"{coins} Coins");
			}
			List<ZoneBlueprintStorePriceItem> list2 = NormalizePriceItems(items);
			if (list2.Count > 0)
			{
				list.Add(FormatPrice(list2));
			}
			if (list.Count != 0)
			{
				return string.Join(", ", list);
			}
			return HomesteadLocalization.Text("hs_common_empty");
		}

		private static List<ZoneBlueprintStorePriceItem> CreatePayoutItems(int coins, IEnumerable<ZoneBlueprintStorePriceItem> materials)
		{
			List<ZoneBlueprintStorePriceItem> list = new List<ZoneBlueprintStorePriceItem>();
			if (coins > 0)
			{
				list.Add(new ZoneBlueprintStorePriceItem
				{
					ItemName = "$item_coins",
					PrefabName = "Coins",
					DisplayName = "$item_coins",
					Amount = coins
				});
			}
			list.AddRange(materials);
			return NormalizePriceItems(list);
		}

		internal static string SerializePriceItems(IEnumerable<ZoneBlueprintStorePriceItem> items)
		{
			//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();
			List<ZoneBlueprintStorePriceItem> list = NormalizePriceItems(items);
			val.Write(1);
			val.Write(list.Count);
			foreach (ZoneBlueprintStorePriceItem item in list)
			{
				val.Write(item.ItemName);
				val.Write(item.PrefabName);
				val.Write(item.DisplayName);
				val.Write(item.Amount);
			}
			return val.GetBase64();
		}

		internal static List<ZoneBlueprintStorePriceItem> DeserializePriceItems(string payload)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			if (string.IsNullOrWhiteSpace(payload))
			{
				return new List<ZoneBlueprintStorePriceItem>();
			}
			try
			{
				ZPackage val = new ZPackage(payload);
				if (val.ReadInt() != 1)
				{
					return new List<ZoneBlueprintStorePriceItem>();
				}
				int num = Mathf.Clamp(val.ReadInt(), 0, 8);
				List<ZoneBlueprintStorePriceItem> list = new List<ZoneBlueprintStorePriceItem>(num);
				for (int i = 0; i < num; i++)
				{
					list.Add(new ZoneBlueprintStorePriceItem
					{
						ItemName = val.ReadString(),
						PrefabName = val.ReadString(),
						DisplayName = val.ReadString(),
						Amount = val.ReadInt()
					});
				}
				return NormalizePriceItems(list);
			}
			catch
			{
				return new List<ZoneBlueprintStorePriceItem>();
			}
		}

		private static void RegisterRpcs()
		{
			RpcRegistrar.EnsureRegistered(delegate(ZRoutedRpc routedRpc)
			{
				routedRpc.Register<ZPackage>("sighsorry.Homestead_BlueprintStoreRequest", (Action<long, ZPackage>)RPC_HandleRequest);
				routedRpc.Register<ZPackage>("sighsorry.Homestead_BlueprintStoreResponse", (Action<long, ZPackage>)RPC_HandleResponse);
			});
		}

		private static void DispatchRequest<TPayload>(string type, TPayload request, Player? player)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				Message(HomesteadLocalization.Text("hs_common_world_not_ready"), (MessageType)2);
				return;
			}
			ZoneBlueprintStoreRpcEnvelope zoneBlueprintStoreRpcEnvelope = CreateEnvelope(type, request);
			if (ZNet.instance.IsServer())
			{
				HandleResponse(ExecuteRequest(zoneBlueprintStoreRpcEnvelope, player, 0L));
				return;
			}
			RegisterRpcs();
			ZPackage val = new ZPackage();
			ZoneBlueprintNetworkPayload.WriteEnvelope(val, HomesteadYaml.Serialize(zoneBlueprintStoreRpcEnvelope), zoneBlueprintStoreRpcEnvelope.BlueprintPayload);
			ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "sighsorry.Homestead_BlueprintStoreRequest", new object[1] { val });
		}

		private static void RPC_HandleRequest(long sender, ZPackage package)
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			if (!ZoneBlueprintNetworkPayload.TryReserveIngress(sender, out string reason))
			{
				SendResponse(sender, CreateEnvelope("error", new ZoneBlueprintStoreStatusResponse
				{
					Success = false,
					Message = reason
				}));
				return;
			}
			ZoneBlueprintNetworkPayload.RawEnvelopePayload rawPayload;
			try
			{
				rawPayload = ZoneBlueprintNetworkPayload.ReadRawEnvelope(package, ZoneBlueprintNetworkPayload.MaxUploadEnvelopeBytes);
			}
			catch (Exception ex)
			{
				_logger.LogError((object)$"Blueprint store RPC failed: {ex}");
				SendResponse(sender, CreateEnvelope("error", new ZoneBlueprintStoreStatusResponse
				{
					Success = false,
					Message = ex.Message
				}));
				return;
			}
			int estimatedBytes = ZoneBlueprintNetworkPayload.EstimateQueuedBytes(rawPayload);
			if (!ZoneBlueprintNetworkPayload.TryEnqueue("Blueprint store RPC", _logger, sender, estimatedBytes, delegate
			{
				ZoneBlueprintStoreRpcEnvelope response;
				try
				{
					byte[] blueprintPayload;
					ZoneBlueprintStoreRpcEnvelope zoneBlueprintStoreRpcEnvelope = HomesteadYaml.Deserialize<ZoneBlueprintStoreRpcEnvelope>(ZoneBlueprintNetworkPayload.ReadEnvelope(rawPayload, out blueprintPayload));
					zoneBlueprintStoreRpcEnvelope.BlueprintPayload = blueprintPayload;
					response = ExecuteRequest(zoneBlueprintStoreRpcEnvelope, null, sender);
				}
				catch (Exception ex2)
				{
					_logger.LogError((object)$"Blueprint store RPC failed: {ex2}");
					response = CreateEnvelope("error", new ZoneBlueprintStoreStatusResponse
					{
						Success = false,
						Message = ex2.Message
					});
				}
				SendResponse(sender, response);
			}, out string reason2))
			{
				SendResponse(sender, CreateEnvelope("error", new ZoneBlueprintStoreStatusResponse
				{
					Success = false,
					Message = reason2
				}));
			}
		}

		private static void RPC_HandleResponse(long sender, ZPackage package)
		{
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
			{
				return;
			}
			try
			{
				byte[] blueprintPayload;
				ZoneBlueprintStoreRpcEnvelope zoneBlueprintStoreRpcEnvelope = HomesteadYaml.Deserialize<ZoneBlueprintStoreRpcEnvelope>(ZoneBlueprintNetworkPayload.ReadEnvelope(package, out blueprintPayload));
				zoneBlueprintStoreRpcEnvelope.BlueprintPayload = blueprintPayload;
				HandleResponse(zoneBlueprintStoreRpcEnvelope);
			}
			catch (Exception ex)
			{
				_logger.LogWarning((object)("Failed to read blueprint store response: " + ex.Message));
			}
		}

		private static void SendResponse(long target, ZoneBlueprintStoreRpcEnvelope response)
		{
			//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();
			ZoneBlueprintNetworkPayload.WriteEnvelope(val, HomesteadYaml.Serialize(response), response.BlueprintPayload);
			ZRoutedRpc.instance.InvokeRoutedRPC(target, "sighsorry.Homestead_BlueprintStoreResponse", new object[1] { val });
		}

		private static void HandleResponse(ZoneBlueprintStoreRpcEnvelope response)
		{
			if (response.Type == "list")
			{
				ZoneBlueprintStoreListResponse zoneBlueprintStoreListResponse = ReadPayload<ZoneBlueprintStoreListResponse>(response);
				if (zoneBlueprintStoreListResponse.IconsOnly)
				{
					ZoneBlueprintStoreUi.ApplyListingIcons(zoneBlueprintStoreListResponse);
					return;
				}
				ZoneBlueprintStoreUi.SetListings(zoneBlueprintStoreListResponse);
				if (zoneBlueprintStoreListResponse.Notifications.Count > 0)
				{
					ZoneBlueprintStoreNotificationsUi.SetNotifications(zoneBlueprintStoreListResponse.Notifications);
				}
			}
			else
			{
				if (response.Type == "sync_hidden" || TryHandleNotificationResponse(response))
				{
					return;
				}
				if (response.Type == "preview")
				{
					ZoneBlueprintStorePreviewResponse zoneBlueprintStorePreviewResponse = ReadPayload<ZoneBlueprintStorePreviewResponse>(response);
					if (zoneBlueprintStorePreviewResponse.Success)
					{
						if (ZoneBlueprintNetworkPayload.TryDeserializeBlueprintPayload(zoneBlueprintStorePreviewResponse.BlueprintPayload, zoneBlueprintStorePreviewResponse.BlueprintEncoding, out ZoneBlueprintFile blueprint, out string reason))
						{
							ZoneBlueprintStorePreviewTool.Activate(zoneBlueprintStorePreviewResponse.ListingId, zoneBlueprintStorePreviewResponse.OfferId, zoneBlueprintStorePreviewResponse.Name, blueprint, allowPurchase: true);
						}
						else
						{
							Message(reason, (MessageType)2);
						}
					}
					else if (!string.IsNullOrWhiteSpace(zoneBlueprintStorePreviewResponse.Message))
					{
						Message(zoneBlueprintStorePreviewResponse.Message, (MessageType)2);
					}
				}
				else if (response.Type == "purchase_complete")
				{
					ZoneBlueprintStorePurchaseCompleteResponse zoneBlueprintStorePurchaseCompleteResponse = ReadPayload<ZoneBlueprintStorePurchaseCompleteResponse>(response);
					if (zoneBlueprintStorePurchaseCompleteResponse.Success)
					{
						if (ZoneBlueprintNetworkPayload.TryDeserializeBlueprintPayload(zoneBlueprintStorePurchaseCompleteResponse.BlueprintPayload, zoneBlueprintStorePurchaseCompleteResponse.BlueprintEncoding, out ZoneBlueprintFile blueprint2, out string reason2))
						{
							string text = ZoneBlueprintCommands.SaveBlueprintFromStore(zoneBlueprintStorePurchaseCompleteResponse.Name, blueprint2);
							ZoneBlueprintSaveTool.QueueMenuRefresh(blueprint2.Name);
							ZoneBlueprintStorePreviewTool.RemovePurchasePreview(zoneBlueprintStorePurchaseCompleteResponse.ListingId, zoneBlueprintStorePurchaseCompleteResponse.OfferId);
							PlayCompletionVfxAtPlayer();
							Message(zoneBlueprintStorePurchaseCompleteResponse.Message + " Saved to " + text, (MessageType)1);
						}
						else
						{
							Message(reason2, (MessageType)2);
						}
					}
					else if (!string.IsNullOrWhiteSpace(zoneBlueprintStorePurchaseCompleteResponse.Message))
					{
						Message(zoneBlueprintStorePurchaseCompleteResponse.Message, (MessageType)2);
					}
				}
				else if (response.Type == "preview_restore")
				{
					ZoneBlueprintStoreChest.HandlePreviewRestoreResponse(ReadPayload<ZoneBlueprintStorePreviewRestoreResponse>(response));
				}
				else if (response.Type == "confirm_listing")
				{
					ZoneBlueprintStoreConfirmListingResponse zoneBlueprintStoreConfirmListingResponse = ReadPayload<ZoneBlueprintStoreConfirmListingResponse>(response);
					if (zoneBlueprintStoreConfirmListingResponse.Success)
					{
						ZoneBlueprintStorePreviewTool.RemoveListingPreview(zoneBlueprintStoreConfirmListingResponse.ListingId);
						PlayCompletionVfxAtPlayer();
						Message(zoneBlueprintStoreConfirmListingResponse.Message, (MessageType)1);
					}
					else if (!string.IsNullOrWhiteSpace(zoneBlueprintStoreConfirmListingResponse.Message))
					{
						Message(zoneBlueprintStoreConfirmListingResponse.Message, (MessageType)2);
					}
				}
				else if (response.Type == "delist")
				{
					ZoneBlueprintStoreStatusResponse zoneBlueprintStoreStatusResponse = ReadPayload<ZoneBlueprintStoreStatusResponse>(response);
					if (!string.IsNullOrWhiteSpace(zoneBlueprintStoreStatusResponse.Message))
					{
						Message(zoneBlueprintStoreStatusResponse.Message, (MessageType)(zoneBlueprintStoreStatusResponse.Success ? 1 : 2));
					}
					if (zoneBlueprintStoreStatusResponse.Success && !ZoneBlueprintStoreUi.TryApplyListingPatch(zoneBlueprintStoreStatusResponse))
					{
						ScheduleListingRefresh();
					}
				}
				else if (response.Type == "edit_price" || response.Type == "create_offer" || response.Type == "decide_offer" || response.Type == "delete_offer")
				{
					ZoneBlueprintStoreStatusResponse zoneBlueprintStoreStatusResponse2 = ReadPayload<ZoneBlueprintStoreStatusResponse>(response);
					if (!string.IsNullOrWhiteSpace(zoneBlueprintStoreStatusResponse2.Message))
					{
						Message(zoneBlueprintStoreStatusResponse2.Message, (MessageType)(zoneBlueprintStoreStatusResponse2.Success ? 1 : 2));
					}
					if (zoneBlueprintStoreStatusResponse2.Success)
					{
						if (response.Type == "decide_offer" || response.Type == "delete_offer")
						{
							ZoneBlueprintStoreOffersUi.RefreshCurrent();
						}
						if (!ZoneBlueprintStoreUi.TryApplyListingPatch(zoneBlueprintStoreStatusResponse2))
						{
							ScheduleListingRefresh();
						}
					}
				}
				else if (response.Type == "list_offers")
				{
					ZoneBlueprintStoreOffersUi.SetOffers(ReadPayload<ZoneBlueprintStoreListOffersResponse>(response));
				}
				else if (response.Type == "price_chest")
				{
					ZoneBlueprintStorePriceChestResponse zoneBlueprintStorePriceChestResponse = ReadPayload<ZoneBlueprintStorePriceChestResponse>(response);
					if (zoneBlueprintStorePriceChestResponse.Success)
					{
						ZoneBlueprintStorePreviewTool.ConfirmPendingListingPreview(zoneBlueprintStorePriceChestResponse.Name, zoneBlueprintStorePriceChestResponse.ListingId);
						TryPlayStoreChestPlaceVfx(zoneBlueprintStorePriceChestResponse.Chest, "price");
					}
					else
					{
						ZoneBlueprintStorePreviewTool.CancelPendingPlacement(response.Type, zoneBlueprintStorePriceChestResponse.ListingId, zoneBlueprintStorePriceChestResponse.Name);
					}
					if (!string.IsNullOrWhiteSpace(zoneBlueprintStorePriceChestResponse.Message))
					{
						Message(zoneBlueprintStorePriceChestResponse.Message, (MessageType)(zoneBlueprintStorePriceChestResponse.Success ? 1 : 2));
					}
				}
				else if (response.Type == "buy")
				{
					ZoneBlueprintStoreBuyResponse zoneBlueprintStoreBuyResponse = ReadPayload<ZoneBlueprintStoreBuyResponse>(response);
					if (zoneBlueprintStoreBuyResponse.Success)
					{
						TryPlayStoreChestPlaceVfx(zoneBlueprintStoreBuyResponse.Chest, "buy");
					}
					else
					{
						ZoneBlueprintStorePreviewTool.CancelPendingPlacement(response.Type, zoneBlueprintStoreBuyResponse.ListingId, zoneBlueprintStoreBuyResponse.Name);
					}
					if (!string.IsNullOrWhiteSpace(zoneBlueprintStoreBuyResponse.Message))
					{
						Message(zoneBlueprintStoreBuyResponse.Message, (MessageType)(zoneBlueprintStoreBuyResponse.Success ? 1 : 2));
					}
				}
				else if (response.Type == "withdraw_complete")
				{
					ZoneBlueprintStoreWithdrawResponse zoneBlueprintStoreWithdrawResponse = ReadPayload<ZoneBlueprintStoreWithdrawResponse>(response);
					if (zoneBlueprintStoreWithdrawResponse.Success)
					{
						ZoneBlueprintStoreUi.SetWithdrawableBalance(hasBalance: false);
						TryPlayStoreChestPlaceVfx(zoneBlueprintStoreWithdrawResponse.Chests, "payout");
					}
					Message(zoneBlueprintStoreWithdrawResponse.Message, (MessageType)(zoneBlueprintStoreWithdrawResponse.Success ? 1 : 2));
				}
				else
				{
					ZoneBlueprintStoreStatusResponse zoneBlueprintStoreStatusResponse3 = ReadPayload<ZoneBlueprintStoreStatusResponse>(response);
					if (!string.IsNullOrWhiteSpace(zoneBlueprintStoreStatusResponse3.Message))
					{
						Message(zoneBlueprintStoreStatusResponse3.Message, (MessageType)(zoneBlueprintStoreStatusResponse3.Success ? 1 : 2));
					}
				}
			}
		}

		private static ZoneBlueprintStoreRpcEnvelope CreateEnvelope<TPayload>(string type, TPayload payload)
		{
			return ZoneBlueprintNetworkPayload.CreateEnvelope<ZoneBlueprintStoreRpcEnvelope, TPayload>(type, payload);
		}

		private static TPayload ReadPayload<TPayload>(ZoneBlueprintStoreRpcEnvelope envelope)
		{
			return ZoneBlueprintNetworkPayload.ReadPayload<TPayload, ZoneBlueprintStoreRpcEnvelope>(envelope);
		}

		private static float SampleGroundY(float x, float z, float fallbackY)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ZoneSystem.instance == (Object)null)
			{
				return fallbackY;
			}
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(x, fallbackY, z);
			Vector3 val2 = default(Vector3);
			Biome val3 = default(Biome);
			BiomeArea val4 = default(BiomeArea);
			Heightmap val5 = default(Heightmap);
			ZoneSystem.instance.GetGroundData(ref val, ref val2, ref val3, ref val4, ref val5);
			return val.y;
		}

		private static void Message(string message, MessageType type)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			ManualLogSource logger = _logger;
			if (logger != null)
			{
				logger.LogInfo((object)message);
			}
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer != null)
			{
				((Character)localPlayer).Message(type, message, 0, (Sprite)null);
			}
		}

		internal static void PlayCompletionVfx(Vector3 position)
		{
			//IL_0055: 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_0060: 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)
			ZNetScene instance = ZNetScene.instance;
			GameObject val = ((instance != null) ? instance.GetPrefab("vfx_HealthUpgrade") : null) ?? PrefabManager.Instance.GetPrefab("vfx_HealthUpgrade");
			if (!Object.op_Implicit((Object)(object)val))
			{
				if (!_storeCompleteVfxMissingLogged)
				{
					_storeCompleteVfxMissingLogged = true;
					ManualLogSource logger = _logger;
					if (logger != null)
					{
						logger.LogWarning((object)"Blueprint store payout VFX prefab 'vfx_HealthUpgrade' was not found.");
					}
				}
			}
			else
			{
				Object.Instantiate<GameObject>(val, position + Vector3.up * 0.75f, Quaternion.identity);
			}
		}

		private static void TryPlayStoreChestPlaceVfx(ZoneBlueprintStoreTransformPayload? payload, string mode)
		{
			//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)
			if ((!((Object)(object)ZNet.instance != (Object)null) || !ZNet.instance.IsServer()) && TryReadTransform(payload, out var position, out var rotation))
			{
				ZoneBlueprintStoreChestPrefab.PlayPlaceEffect(mode, position, rotation);
			}
		}

		private static void TryPlayStoreChestPlaceVfx(IEnumerable<ZoneBlueprintStoreTransformPayload>? payloads, string mode)
		{
			//IL_0039: 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)
			if (((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer()) || payloads == null)
			{
				return;
			}
			foreach (ZoneBlueprintStoreTransformPayload payload in payloads)
			{
				if (TryReadTransform(payload, out var position, out var rotation))
				{
					ZoneBlueprintStoreChestPrefab.PlayPlaceEffect(mode, position, rotation);
				}
			}
		}

		private static void PlayCompletionVfxAtPlayer()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null))
			{
				PlayCompletionVfx(((Component)localPlayer).transform.position);
			}
		}

		internal static GameObject? FindItemPrefab(string prefabName)
		{
			if (string.IsNullOrWhiteSpace(prefabName))
			{
				return null;
			}
			ObjectDB instance = ObjectDB.instance;
			object obj = ((instance != null) ? instance.GetItemPrefab(prefabName) : null);
			if (obj == null)
			{
				ZNetScene instance2 = ZNetScene.instance;
				if (instance2 == null)
				{
					return null;
				}
				obj = instance2.GetPrefab(prefabName);
			}
			return (GameObject?)obj;
		}

		private static GameObject? FindItemPrefabByDisplayName(string token)
		{
			if ((Object)(object)ObjectDB.instance == (Object)null)
			{
				return null;
			}
			foreach (GameObject item in ObjectDB.instance.m_items)
			{
				if (!Object.op_Implicit((Object)(object)item))
				{
					continue;
				}
				ItemDrop component = item.GetComponent<ItemDrop>();
				if (!((Object)(object)component == (Object)null))
				{
					string prefabName = Utils.GetPrefabName(item);
					string name = component.m_itemData.m_shared.m_name;
					string a = ((Localization.instance != null) ? Localization.instance.Localize(name) : name);
					if (string.Equals(prefabName, token, StringComparison.OrdinalIgnoreCase) || string.Equals(name, token, StringComparison.OrdinalIgnoreCase) || string.Equals(a, token, StringComparison.OrdinalIgnoreCase))
					{
						return item;
					}
				}
			}
			return null;
		}
	}
	internal sealed class ZoneBlueprintStoreChest : MonoBehaviour
	{
		internal const string ListingIdKey = "hs_store_listing";

		internal const string ModeKey = "hs_store_mode";

		internal const string ModePrice = "price";

		internal const string ModePurchase = "buy";

		internal const string ModePayout = "payout";

		internal const int MaxPriceItemTypes = 8;

		internal const string BuyerPlayerIdKey = "hs_store_buyer";

		internal const string SellerPlayerIdKey = "hs_store_seller";

		private const string BuyerNameKey = "hs_store_buyer_name";

		private const string SellerNameKey = "hs_store_seller_name";

		internal const string BlueprintNameKey = "hs_store_blueprint_name";

		internal const string BlueprintFileKey = "hs_store_blueprint_file";

		private const string IconPngKey = "hs_store_icon_png";

		private const string EntryCountKey = "hs_store_entry_count";

		private const string PricePayloadKey = "hs_store_price_payload";

		private const string PurchaseDepositPayloadKey = "hs_store_purchase_deposit_payload";

		internal const string OfferIdKey = "hs_store_offer";

		internal const string ConfirmedKey = "hs_store_confirmed";

		internal const string DraftOwnedByChestKey = "hs_store_draft_owned_by_chest";

		private const float CleanupCheckInterval = 30f;

		private const int PreviewRestoreBlueprintCacheLimit = 32;

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

		private static readonly Queue<string> PreviewRestoreBlueprintCacheOrder = new Queue<string>();

		private static readonly HashSet<string> PendingPreviewRestoreFiles = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private ZNetView? _nview;

		private Container? _container;

		private int _lastInventorySignatureHash;

		private bool _hasInventorySignature;

		private string _cachedMode = "";

		private string _cachedListingId = "";

		private string _cachedBlueprintName = "";

		private readonly ZoneBlueprintGhostOwner _ownedPreview = new ZoneBlueprintGhostOwner();

		private bool _previewRestoreRequested;

		private float _nextCleanupCheck;

		internal static void ResetPreviewRestoreCacheForWorldSession()
		{
			PreviewRestoreBlueprintCache.Clear();
			PreviewRestoreBlueprintCacheOrder.Clear();
			PendingPreviewRestoreFiles.Clear();
		}

		private void Awake()
		{
			_nview = ((Component)this).GetComponent<ZNetView>();
			_container = ((Component)this).GetComponent<Container>();
			((MonoBehaviour)this).InvokeRepeating("Tick", 0.5f, 0.5f);
			ZoneBlueprintChestZdoRegistry.Refresh(((Object)(object)_nview != (Object)null && _nview.IsValid()) ? _nview.GetZDO() : null);
			ZoneBlueprintStoreChestRegistry.Refresh(this);
		}

		public void SetPurchase(ZoneBlueprintStoreListing listing, IReadOnlyList<ZoneBlueprintStorePriceItem> priceItems, string offerId, long buyerPlayerId, string buyerName, string buyerPlatformId, Vector3 previewAnchor, Quaternion previewRotation)
		{
			//IL_00fd: 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)
			if (!((Object)(object)_nview == (Object)null) && _nview.IsValid())
			{
				ZDO zDO = _nview.GetZDO();
				zDO.Set("hs_store_mode", "buy");
				zDO.Set("hs_store_listing", listing.ListingId);
				zDO.Set("hs_store_blueprint_name", listing.Name);
				zDO.Set("hs_store_blueprint_file", listing.BlueprintFile);
				zDO.Set("hs_store_icon_png", listing.IconPngBase64);
				zDO.Set("hs_store_entry_count", listing.EntryCount);
				zDO.Set("hs_store_buyer", buyerPlayerId);
				zDO.Set("hs_store_buyer_name", buyerName);
				ZoneBlueprintChestLifecycle.SetOwnerPlatformId(zDO, buyerPlatformId);
				zDO.Set("hs_store_price_payload", ZoneBlueprintStore.SerializePriceItems(priceItems));
				zDO.Set("hs_store_purchase_deposit_payload", "");
				zDO.Set("hs_store_offer", offerId ?? "");
				zDO.Set("hs_store_confirmed", false);
				zDO.Set("hs_store_draft_owned_by_chest", false);
				ZoneBlueprintStorePreviewPayload.Write(zDO, previewAnchor, previewRotation);
				_cachedMode = "buy";
				_cachedListingId = listing.ListingId;
				_cachedBlueprintName = listing.Name;
				ZoneBlueprintChestLifecycle.Initialize(zDO);
				ZoneBlueprintStoreChestRegistry.Refresh(this);
				if (ZoneBlueprintStorePreviewPayload.CanCreateLocalPreview)
				{
					TryClaimLocalPreview();
				}
			}
		}

		public void SetPriceDraft(string listingId, string blueprintName, string blueprintFile, string iconPngBase64, int entryCount, long sellerPlayerId, string sellerName, string sellerPlatformId, Vector3 previewAnchor, Quaternion previewRotation)
		{
			//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 (!((Object)(object)_nview == (Object)null) && _nview.IsValid())
			{
				ZDO zDO = _nview.GetZDO();
				zDO.Set("hs_store_mode", "price");
				zDO.Set("hs_store_listing", listingId);
				zDO.Set("hs_store_blueprint_name", blueprintName);
				zDO.Set("hs_store_blueprint_file", blueprintFile);
				zDO.Set("hs_store_icon_png", iconPngBase64);
				zDO.Set("hs_store_entry_count", entryCount);
				zDO.Set("hs_store_seller", sellerPlayerId);
				zDO.Set("hs_store_seller_name", sellerName);
				ZoneBlueprintChestLifecycle.SetOwnerPlatformId(zDO, sellerPlatformId);
				zDO.Set("hs_store_confirmed", false);
				zDO.Set("hs_store_draft_owned_by_chest", true);
				ZoneBlueprintStorePreviewPayload.Write(zDO, previewAnchor, previewRotation);
				_cachedMode = "price";
				_cachedListingId = listingId;
				_cachedBlueprintName = blueprintName;
				ZoneBlueprintChestLifecycle.Initialize(zDO);
				ZoneBlueprintStoreChestRegistry.Refresh(this);
				if (ZoneBlueprintStorePreviewPayload.CanCreateLocalPreview)
				{
					TryClaimLocalPreview();
				}
			}
		}

		public void SetPayout(long sellerPlayerId, string sellerName, string sellerPlatformId)
		{
			if (!((Object)(object)_nview == (Object)null) && _nview.IsValid())
			{
				ZDO zDO = _nview.GetZDO();
				zDO.Set("hs_store_mode", "payout");
				zDO.Set("hs_store_seller", sellerPlayerId);
				zDO.Set("hs_store_seller_name", sellerName);
				ZoneBlueprintChestLifecycle.SetOwnerPlatformId(zDO, sellerPlatformId);
				zDO.Set("hs_store_confirmed", false);
				_cachedMode = "payout";
				_cachedListingId = "";
				_cachedBlueprintName = "";
				ZoneBlueprintChestLifecycle.Initialize(zDO);
				ZoneBlueprintStoreChestRegistry.Refresh(this);
			}
		}

		public string GetHoverText()
		{
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_nview == (Object)null || !_nview.IsValid())
			{
				return HomesteadLocalization.Text("hs_store_chest_name");
			}
			if (IsPriceMode())
			{
				string @string = _nview.GetZDO().GetString("hs_store_blueprint_name", HomesteadLocalization.Text("hs_store_default_blueprint"));
				string text = ZoneBlueprintStore.FormatPrice(ReadPriceItems());
				string text2 = HomesteadLocalization.Format("hs_store_listing_hover", @string, text);
				text2 = text2 + HomesteadLocalization.Format("hs_hover_action", "$KEY_Use", HomesteadLocalization.Text("hs_store_edit_price_action")) + "\n";
				text2 += HomesteadLocalization.Format("hs_hover_action", FormatShortcut(BlueprintConfig.ChestConfirmHotkey), HomesteadLocalization.Text("hs_store_list_on_store"));
				return Localization.instance.Localize(text2);
			}
			if (IsPayoutMode())
			{
				string string2 = _nview.GetZDO().GetString("hs_store_seller_name", HomesteadLocalization.Text("hs_common_unknown"));
				string text3 = HomesteadLocalization.Format("hs_store_payout_hover", string2);
				text3 += HomesteadLocalization.Format("hs_hover_action", "$KEY_Use", HomesteadLocalization.Text("hs_common_open"));
				return Localization.instance.Localize(text3);
			}
			List<ZoneBlueprintStorePriceItem> priceItems = GetPriceItems();
			string text4 = HomesteadLocalization.Format("hs_store_purchase_hover", FormatDeposited(priceItems));
			text4 += HomesteadLocalization.Format("hs_hover_action", FormatShortcut(BlueprintConfig.ChestConfirmHotkey), HomesteadLocalization.Text("hs_store_confirm_purchase"));
			return Localization.instance.Localize(text4);
		}

		public bool TryConfirm(Player player)
		{
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_nview == (Object)null || !_nview.IsValid())
			{
				return true;
			}
			ZDO zDO = _nview.GetZDO();
			ZoneBlueprintStoreActor zoneBlueprintStoreActor = ZoneBlueprintStoreIdentity.Actor(player.GetPlayerID(), HomesteadPlayerIdentity.ResolveLocalPlatformId(player.GetPlayerID()));
			string ownerPlatformId = ZoneBlueprintChestLifecycle.GetOwnerPlatformId(zDO);
			string @string = zDO.GetString("hs_store_listing", "");
			if (string.IsNullOrWhiteSpace(@string))
			{
				return true;
			}
			Touch();
			if (IsPriceMode())
			{
				long @long = zDO.GetLong("hs_store_seller", 0L);
				if (@long != 0L && !zoneBlueprintStoreActor.MatchesStored(@long, ownerPlatformId, BlueprintConfig.StoreIdentityMode))
				{
					((Character)player).Message((MessageType)2, HomesteadLocalization.Text("hs_store_other_seller"), 0, (Sprite)null);
					return true;
				}
				if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
				{
					HomesteadCommandResult homesteadCommandResult = ZoneBlueprintStore.ConfirmListingLocal(@string, player.GetPlayerID(), this, ReadPriceItems());
					((Character)player).Message((MessageType)(homesteadCommandResult.Success ? 1 : 2), homesteadCommandResult.Message, 0, (Sprite)null);
					if (homesteadCommandResult.Success)
					{
						ZoneBlueprintStorePreviewTool.RemoveListingPreview(@string);
						ZoneBlueprintStore.PlayCompletionVfx(((Component)player).transform.position);
					}
					return true;
				}
				ZoneBlueprintStore.RequestConfirmListing(@string, ReadPriceItems());
				((Character)player).Message((MessageType)1, HomesteadLocalization.Text("hs_store_listing_request_sent"), 0, (Sprite)null);
				return true;
			}
			long long2 = zDO.GetLong("hs_store_buyer", 0L);
			if (long2 != 0L && !zoneBlueprintStoreActor.MatchesStored(long2, ownerPlatformId, BlueprintConfig.StoreIdentityMode))
			{
				((Character)player).Message((MessageType)2, HomesteadLocalization.Text("hs_store_other_buyer"), 0, (Sprite)null);
				return true;
			}
			if (BlueprintConfig.AzuCraftyBoxesPullOnConfirm)
			{
				TryPullAvailableMaterials(player, "confirm", message: true);
			}
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
			{
				HomesteadCommandResult homesteadCommandResult2 = ZoneBlueprintStore.ConfirmPurchaseLocal(@string, player.GetPlayerID(), player.GetPlayerName(), this);
				((Character)player).Message((MessageType)(homesteadCommandResult2.Success ? 1 : 2), homesteadCommandResult2.Message, 0, (Sprite)null);
				if (homesteadCommandResult2.Success)
				{
					ZoneBlueprintStorePreviewTool.RemovePurchasePreview(@string);
					ZoneBlueprintStore.PlayCompletionVfx(((Component)player).transform.position);
				}
				return true;
			}
			ZoneBlueprintStore.RequestConfirmPurchase(@string, GetOfferId());
			((Character)player).Message((MessageType)1, HomesteadLocalization.Text("hs_store_purchase_request_sent"), 0, (Sprite)null);
			return true;
		}

		public bool TryReadListingDraft(out string name, out string sellerName, out string blueprintFile, out int entryCount, out string reason)
		{
			return TryReadListingDraft(((Object)(object)_nview != (Object)null && _nview.IsValid()) ? _nview.GetZDO() : null, out name, out sellerName, out blueprintFile, out entryCount, out reason);
		}

		internal static bool TryReadListingDraft(ZDO? zdo, out string name, out string sellerName, out string blueprintFile, out int entryCount, out string reason)
		{
			name = "";
			sellerName = "";
			blueprintFile = "";
			entryCount = 0;
			reason = "";
			if (zdo == null || !zdo.IsValid() || !string.Equals(zdo.GetString("hs_store_mode", ""), "price", StringComparison.Ordinal))
			{
				reason = HomesteadLocalization.Text("hs_store_listing_chest_not_ready");
				return false;
			}
			name = zdo.GetString("hs_store_blueprint_name", "");
			sellerName = zdo.GetString("hs_store_seller_name", HomesteadLocalization.Text("hs_common_unknown"));
			blueprintFile = zdo.GetString("hs_store_blueprint_file", "");
			entryCount = zdo.GetInt("hs_store_entry_count", 0);
			if (string.IsNullOrWhiteSpace(name) || string.IsNullOrWhiteSpace(blueprintFile))
			{
				reason = HomesteadLocalization.Text("hs_store_listing_draft_missing_data");
				return false;
			}
			return true;
		}

		public bool TryTakePriceItems(IEnumerable<ZoneBlueprintStorePriceItem> priceItems, out string deposited)
		{
			if (!CanTakePriceItems(priceItems, out deposited))
			{
				return false;
			}
			SetDepositedPriceItems(Array.Empty<ZoneBlueprintStorePriceItem>());
			Container? container = _container;
			if (container != null)
			{
				container.Save();
			}
			Touch();
			return true;
		}

		public string GetOfferId()
		{
			ZNetView? nview = _nview;
			object obj;
			if (nview == null)
			{
				obj = null;
			}
			else
			{
				ZDO zDO = nview.GetZDO();
				obj = ((zDO != null) ? zDO.GetString("hs_store_offer", "") : null);
			}
			if (obj == null)
			{
				obj = "";
			}
			return (string)obj;
		}

		public bool CanTakePriceItems(IEnumerable<ZoneBlueprintStorePriceItem> priceItems, out string deposited)
		{
			return CreatePurchaseEscrow(ZoneMaterialEscrow.ToRequirements(priceItems)).HasAllRequired(out deposited);
		}

		internal static bool CanTakePurchasePriceItems(ZDO? zdo, IEnumerable<ZoneBlueprintStorePriceItem> priceItems, out string deposited)
		{
			return CreatePurchaseEscrow(zdo, ZoneMaterialEscrow.ToRequirements(priceItems)).HasAllRequired(out deposited);
		}

		internal static bool TryTakePurchasePriceItems(ZDO? zdo, IEnumerable<ZoneBlueprintStorePriceItem> priceItems, out string deposited)
		{
			if (!CanTakePurchasePriceItems(zdo, priceItems, out deposited))
			{
				return false;
			}
			SetDepositedPriceItems(zdo, Array.Empty<ZoneBlueprintStorePriceItem>());
			ZoneBlueprintChestZdoRegistry.Refresh(zdo);
			return true;
		}

		public bool TryAcceptPurchaseMaterialFromInventory(Inventory sourceInventory, ItemData item, int requestedAmount, bool message)
		{
			if (!IsPurchaseMode() || _container?.m_inventory == null || sourceInventory == null || item == null || requestedAmount <= 0)
			{
				return false;
			}
			int num = CreatePurchaseEscrow().AcceptNeededOnly(sourceInventory, item, requestedAmount);
			if (num > 0)
			{
				_container.Save();
				Touch();
				if (message && (Object)(object)Player.m_localPlayer != (Object)null && num < requestedAmount)
				{
					((Character)Player.m_localPlayer).Message((MessageType)2, HomesteadLocalization.Format("hs_store_accepted_excess_inventory", num), 0, (Sprite)null);
				}
				return true;
			}
			if (message && (Object)(object)Player.m_localPlayer != (Object)null)
			{
				((Character)Player.m_localPlayer).Message((MessageType)2, HomesteadLocalization.Text("hs_store_material_not_needed_purchase"), 0, (Sprite)null);
			}
			return false;
		}

		public bool TryAcceptAllPurchaseMaterialsFromPlayer(Player player)
		{
			Player player2 = player;
			if ((Object)(object)player2 == (Object)null || !IsPurchaseMode() || _container?.m_inventory == null)
			{
				return false;
			}
			int num = AcceptAllPurchaseMaterialsFromInventory(((Humanoid)player2).GetInventory(), (ItemData item) => item.m_shared.m_questItem || ((Humanoid)player2).IsItemEquiped(item));
			if (num > 0)
			{
				_container.Save();
				Touch();
				((Character)player2).Message((MessageType)2, HomesteadLocalization.Format("hs_store_accepted_purchase_materials", num), 0, (Sprite)null);
				return true;
			}
			((Character)player2).Message((MessageType)2, HomesteadLocalization.Text("hs_store_no_matching_purchase_materials"), 0, (Sprite)null);
			return false;
		}

		public int TryPullAvailableMaterials(Player player, string trigger, bool message)
		{
			Player player2 = player;
			if ((Object)(object)player2 == (Object)null || !IsPurchaseMode() || _container?.m_inventory == null)
			{
				return 0;
			}
			int num = AcceptAllPurchaseMaterialsFromInventory(((Humanoid)player2).GetInventory(), (ItemData item) => item.m_shared.m_questItem || ((Humanoid)player2).IsItemEquiped(item));
			int num2 = 0;
			if ((trigger == "confirm" && BlueprintConfig.AzuCraftyBoxesPullOnConfirm) || (trigger == "open" && BlueprintConfig.AzuCraftyBoxesPullOnOpen))
			{
				num2 = CreatePurchaseEscrow().PullNearbyContainers();
			}
			int num3 = num + num2;
			if (num3 > 0)
			{
				_container.Save();
				Touch();
				if (message)
				{
					((Character)player2).Message((MessageType)1, HomesteadLocalization.Format("hs_store_pulled_purchase_materials", num3, num, num2), 0, (Sprite)null);
				}
			}
			return num3;
		}

		private int AcceptAllPurchaseMaterialsFromInventory(Inventory sourceInventory, Func<ItemData, bool>? skip = null)
		{
			if (sourceInventory == null)
			{
				return 0;
			}
			return CreatePurchaseEscrow().AcceptAllNeeded(sourceInventory, skip);
		}

		public List<ZoneBlueprintStorePriceItem> ReadPriceItems()
		{
			if (IsPriceMode())
			{
				List<ZoneBlueprintStorePriceItem> priceItems = GetPriceItems();
				if (priceItems.Count > 0)
				{
					return priceItems;
				}
			}
			return ZoneMaterialEscrow.ReadPriceItems(_container?.m_inventory);
		}

		public void SetPriceItems(IReadOnlyList<ZoneBlueprintStorePriceItem> priceItems)
		{
			if (!((Object)(object)_nview == (Object)null) && _nview.IsValid() && IsPriceMode())
			{
				_nview.GetZDO().Set("hs_store_price_payload", ZoneBlueprintStore.SerializePriceItems(priceItems));
				Touch();
			}
		}

		public string GetIconPngBase64()
		{
			ZNetView? nview = _nview;
			object obj;
			if (nview == null)
			{
				obj = null;
			}
			else
			{
				ZDO zDO = nview.GetZDO();
				obj = ((zDO != null) ? zDO.GetString("hs_store_icon_png", "") : null);
			}
			if (obj == null)
			{
				obj = "";
			}
			return (string)obj;
		}

		internal static string GetIconPngBase64(ZDO? zdo)
		{
			return ((zdo != null) ? zdo.GetString("hs_store_icon_png", "") : null) ?? "";
		}

		public string GetBlueprintNameForUi()
		{
			ZNetView? nview = _nview;
			object obj;
			if (nview == null)
			{
				obj = null;
			}
			else
			{
				ZDO zDO = nview.GetZDO();
				obj = ((zDO != null) ? zDO.GetString("hs_store_blueprint_name", "Blueprint") : null);
			}
			if (obj == null)
			{
				obj = "Blueprint";
			}
			return (string)obj;
		}

		public void MarkConfirmed()
		{
			ZNetView? nview = _nview;
			MarkConfirmed((nview != null) ? nview.GetZDO() : null);
			ZoneBlueprintStoreChestRegistry.Refresh(this);
		}

		internal static void MarkConfirmed(ZDO? zdo)
		{
			if (zdo != null)
			{
				zdo.Set("hs_store_confirmed", true);
			}
			ZoneBlueprintChestZdoRegistry.Refresh(zdo);
		}

		public void ReleaseDraftFileOwnership()
		{
			ZNetView? nview = _nview;
			ZDO obj = ((nview != null) ? nview.GetZDO() : null);
			if (obj != null)
			{
				obj.Set("hs_store_draft_owned_by_chest", false);
			}
			ZoneBlueprintChestZdoRegistry.Refresh(obj);
		}

		public void CleanupOwnedDraftFile(string source)
		{
			if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer() && !((Object)(object)_nview == (Object)null))
			{
				ZDO zDO = _nview.GetZDO();
				if (zDO != null && string.Equals(zDO.GetString("hs_store_mode", ""), "price", StringComparison.Ordinal) && !zDO.GetBool("hs_store_confirmed", false) && zDO.GetBool("hs_store_draft_owned_by_chest", false))
				{
					string @string = zDO.GetString("hs_store_blueprint_file", "");
					ZoneBlueprintStoreDraftRepository.DeleteFile(@string);
					zDO.Set("hs_store_draft_owned_by_chest", false);
					ZoneBlueprintChestZdoRegistry.Refresh(zDO);
					HomesteadPlugin.HomesteadLogger.LogInfo((object)("Blueprint store draft cleanup (" + source + "): " + Path.GetFileName(@string)));
				}
			}
		}

		public void PlayCompletionVfx()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			ZoneBlueprintStore.PlayCompletionVfx(((Component)this).transform.position);
		}

		public void DropAllContents()
		{
			//IL_001f: 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)
			if (IsPurchaseMode())
			{
				List<ZoneBlueprintStorePriceItem> depositedPriceItems = GetDepositedPriceItems();
				if (depositedPriceItems.Count > 0)
				{
					ZoneMaterialEscrow.DropPriceItems(depositedPriceItems, ((Component)this).transform.position);
					SetDepositedPriceItems(Array.Empty<ZoneBlueprintStorePriceItem>());
				}
			}
			ZoneMaterialEscrow.DropAllContents(_container?.m_inventory, ((Component)this).transform.position);
			Container? container = _container;
			if (container != null)
			{
				container.Save();
			}
		}

		public bool PreparePayoutInventory(IReadOnlyList<ZoneBlueprintStorePriceItem> stacks)
		{
			//IL_0044: 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_0085: Expected O, but got Unknown
			if ((Object)(object)_container == (Object)null)
			{
				return false;
			}
			_container.m_name = HomesteadLocalization.Token("hs_store_payout_chest_name");
			_container.m_width = 8;
			_container.m_height = 4;
			_container.m_privacy = (PrivacySetting)0;
			_container.m_inventory = new Inventory(_container.m_name, _container.m_bkg, _container.m_width, _container.m_height);
			Inventory inventory = _container.m_inventory;
			inventory.m_onChanged = (Action)Delegate.Combine(inventory.m_onChanged, new Action(_container.OnContainerChanged));
			bool num = ZoneMaterialEscrow.TryFillInventory(_container.m_inventory, stacks);
			if (num)
			{
				_container.Save();
				Touch();
			}
			return num;
		}

		public void DestroyChest()
		{
			ReleaseAzuCraftyBoxesContainer("StoreChest.DestroyChest");
			if ((Object)(object)_nview != (Object)null && _nview.IsValid())
			{
				_nview.Destroy();
			}
			else
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}

		internal void ReleaseAzuCraftyBoxesContainer(string source)
		{
			AzuCraftyBoxesCompat.RemoveContainer((Container?)(((Object)(object)_container != (Object)null && Object.op_Implicit((Object)(object)_container)) ? ((object)_container) : ((object)((Component)this).GetComponent<Container>())), source);
		}

		private void Tick()
		{
			if ((Object)(object)_nview == (Object)null || !_nview.IsValid())
			{
				return;
			}
			RefreshCachedIdentity();
			if (ZoneBlueprintStorePreviewPayload.CanCreateLocalPreview)
			{
				TryClaimLocalPreview();
			}
			if (_nview.IsOwner())
			{
				if (IsPurchaseMode())
				{
					AbsorbPurchaseInventoryMaterials();
				}
				TouchWhenInventoryChanged();
				if (!CheckPayoutEmptied())
				{
					CheckAutoCleanup();
				}
			}
		}

		public void Touch()
		{
			ZoneBlueprintChestLifecycle.Touch(_nview);
		}

		public bool IsPurchaseChest()
		{
			return IsPurchaseMode();
		}

		public bool IsPriceChest()
		{
			return IsPriceMode();
		}

		public bool IsPriceChestPrefab()
		{
			ZDO val = (((Object)(object)_nview != (Object)null && _nview.IsValid()) ? _nview.GetZDO() : null);
			if (val != null && val.GetPrefab() == ZoneBlueprintStoreChestPrefab.PricePrefabHash)
			{
				return true;
			}
			if ((Object)(object)((Component)this).gameObject != (Object)null)
			{
				return ((Object)((Component)this).gameObject).name.StartsWith("piece_chest_barrel_blueprint_store_price", StringComparison.OrdinalIgnoreCase);
			}
			return false;
		}

		public bool IsPayoutChest()
		{
			return IsPayoutMode();
		}

		public void DrawRequirementOverlay(InventoryGrid grid)
		{
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)grid == (Object)null || !IsPurchaseMode())
			{
				return;
			}
			List<ZoneBlueprintRequirement> missingPurchaseRequirementList = GetMissingPurchaseRequirementList();
			int num = 0;
			foreach (Element element in grid.m_elements)
			{
				if (num >= missingPurchaseRequirementList.Count)
				{
					break;
				}
				if (!element.m_used)
				{
					ZoneBlueprintRequirement zoneBlueprintRequirement = missingPurchaseRequirementList[num++];
					Sprite requirementIcon = GetRequirementIcon(zoneBlueprintRequirement);
					element.m_used = true;
					((Behaviour)element.m_icon).enabled = (Object)(object)requirementIcon != (Object)null;
					element.m_icon.sprite = requirementIcon;
					((Graphic)element.m_icon).color = new Color(1f, 1f, 1f, 0.45f);
					((Behaviour)element.m_amount).enabled = true;
					element.m_amount.text = zoneBlueprintRequirement.Amount.ToString();
					((Behaviour)element.m_quality).enabled = false;
					((Behaviour)element.m_equiped).enabled = false;
					((Behaviour)element.m_queued).enabled = false;
					((Behaviour)element.m_noteleport).enabled = false;
					((Behaviour)element.m_food).enabled = false;
					((Component)element.m_durability).gameObject.SetActive(false);
					element.m_tooltip.m_topic = Localization.instance.Localize(zoneBlueprintRequirement.DisplayName);
					element.m_tooltip.m_text = HomesteadLocalization.Format("hs_store_requirement_tooltip", zoneBlueprintRequirement.Amount);
				}
			}
		}

		public List<ZoneBlueprintRequirement> GetMissingPurchaseRequirementList()
		{
			if (!IsPurchaseMode())
			{
				return new List<ZoneBlueprintRequirement>();
			}
			return CreatePurchaseEscrow().GetMissingRequirements();
		}

		private void TouchWhenInventoryChanged()
		{
			int inventorySignatureHash = GetInventorySignatureHash();
			if (!_hasInventorySignature)
			{
				_lastInventorySignatureHash = inventorySignatureHash;
				_hasInventorySignature = true;
			}
			else if (inventorySignatureHash != _lastInventorySignatureHash)
			{
				_lastInventorySignatureHash = inventorySignatureHash;
				Touch();
			}
		}

		private void CheckAutoCleanup()
		{
			if (Time.time < _nextCleanupCheck)
			{
				return;
			}
			_nextCleanupCheck = Time.time + 30f;
			ZNetView? nview = _nview;
			ZDO val = ((nview != null) ? nview.GetZDO() : null);
			if (val != null && (IsPriceMode() || IsPurchaseMode() || IsPayoutMode()) && ZoneBlueprintChestLifecycle.IsExpired(val, BlueprintConfig.ChestTimeoutMinutes) && !HasRetainedMaterials())
			{
				if (IsPriceMode())
				{
					CleanupOwnedDraftFile("timeout");
				}
				MarkConfirmed();
				DestroyChest();
			}
		}

		private bool CheckPayoutEmptied()
		{
			if (!IsPayoutMode())
			{
				return false;
			}
			ZNetView? nview = _nview;
			ZDO val = ((nview != null) ? nview.GetZDO() : null);
			if (val != null && val.GetBool("hs_store_confirmed", false))
			{
				return false;
			}
			Container? container = _container;
			int? obj;
			if (container == null)
			{
				obj = null;
			}
			else
			{
				Inventory inventory = container.m_inventory;
				obj = ((inventory != null) ? new int?(inventory.NrOfItems()) : null);
			}
			int? num = obj;
			if (num.GetValueOrDefault() > 0)
			{
				return false;
			}
			PlayPayoutEmptiedVfx();
			MarkConfirmed();
			DestroyChest();
			return true;
		}

		private void PlayPayoutEmptiedVfx()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: 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 position = ((Component)this).transform.position;
			Quaternion rotation = ((Component)this).transform.rotation;
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
			{
				if ((Object)(object)Player.m_localPlayer != (Object)null)
				{
					ZoneBlueprintStore.PlayCompletionVfx(position);
				}
				ZoneBlueprintChestVfx.BroadcastPayoutComplete(position, rotation, 0L);
			}
			else
			{
				ZoneBlueprintStore.PlayCompletionVfx(position);
			}
		}

		private bool HasRetainedMaterials()
		{
			Container? container = _container;
			int? obj;
			if (container == null)
			{
				obj = null;
			}
			else
			{
				Inventory inventory = container.m_inventory;
				obj = ((inventory != null) ? new int?(inventory.NrOfItems()) : null);
			}
			int? num = obj;
			if (num.GetValueOrDefault() > 0)
			{
				return true;
			}
			if (IsPurchaseMode())
			{
				return GetDepositedPriceItems().Any((ZoneBlueprintStorePriceItem item) => item.Amount > 0);
			}
			return false;
		}

		private int GetInventorySignatureHash()
		{
			Inventory val = _container?.m_inventory;
			if (val == null)
			{
				return 0;
			}
			int num = 17;
			int num2 = 0;
			foreach (ItemData allItem in val.GetAllItems())
			{
				string obj = allItem.m_shared?.m_name ?? "";
				int hashCode = StringComparer.Ordinal.GetHashCode(obj);
				hashCode = (hashCode * 397) ^ allItem.m_stack;
				num += hashCode;
				num ^= (hashCode << 7) | (hashCode >>> 25);
				num2++;
			}
			return (num * 397) ^ num2;
		}

		private void RefreshCachedIdentity()
		{
			ZDO val = (((Object)(object)_nview != (Object)null && _nview.IsValid()) ? _nview.GetZDO() : null);
			if (val != null)
			{
				string @string = val.GetString("hs_store_mode", _cachedMode);
				string string2 = val.GetString("hs_store_listing", _cachedListingId);
				string string3 = val.GetString("hs_store_blueprint_name", _cachedBlueprintName);
				bool num = !string.Equals(@string, _cachedMode, StringComparison.Ordinal) || !string.Equals(string2, _cachedListingId, StringComparison.Ordinal) || !string.Equals(string3, _cachedBlueprintName, StringComparison.Ordinal);
				_cachedMode = @string;
				_cachedListingId = string2;
				_cachedBlueprintName = string3;
				if (num)
				{
					ZoneBlueprintChestZdoRegistry.Refresh(val);
					ZoneBlueprintStoreChestRegistry.Refresh(this);
				}
			}
		}

		internal bool TryGetStoreLookup(out string mode, out string listingId, out ZoneBlueprintStoreActor actor)
		{
			mode = "";
			listingId = "";
			actor = default(ZoneBlueprintStoreActor);
			ZDO val = (((Object)(object)_nview != (Object)null && _nview.IsValid()) ? _nview.GetZDO() : null);
			if (val == null || val.GetBool("hs_store_confirmed", false))
			{
				return false;
			}
			mode = val.GetString("hs_store_mode", "");
			listingId = val.GetString("hs_store_listing", "");
			if (string.Equals(mode, "payout", StringComparison.Ordinal))
			{
				actor = ZoneBlueprintStoreIdentity.Actor(val.GetLong("hs_store_seller", 0L), ZoneBlueprintChestLifecycle.GetOwnerPlatformId(val));
				return actor.IsValid;
			}
			if (string.Equals(mode, "buy", StringComparison.Ordinal))
			{
				if (string.IsNullOrWhiteSpace(listingId))
				{
					return false;
				}
				actor = ZoneBlueprintStoreIdentity.Actor(val.GetLong("hs_store_buyer", 0L), ZoneBlueprintChestLifecycle.GetOwnerPlatformId(val));
				return actor.IsValid;
			}
			if (string.Equals(mode, "price", StringComparison.Ordinal))
			{
				if (string.IsNullOrWhiteSpace(listingId))
				{
					return false;
				}
				actor = ZoneBlueprintStoreIdentity.Actor(val.GetLong("hs_store_seller", 0L), ZoneBlueprintChestLifecycle.GetOwnerPlatformId(val));
				return actor.IsValid;
			}
			return false;
		}

		internal bool TryResolvePriceDraftRestore(string requestListingId, string requestBlueprintFile, out string name, out string blueprintFile)
		{
			name = "";
			blueprintFile = "";
			ZDO val = (((Object)(object)_nview != (Object)null && _nview.IsValid()) ? _nview.GetZDO() : null);
			if (val == null || !string.Equals(val.GetString("hs_store_mode", ""), "price", StringComparison.Ordinal) || val.GetBool("hs_store_confirmed", false) || !val.GetBool("hs_store_draft_owned_by_chest", false))
			{
				return false;
			}
			string @string = val.GetString("hs_store_listing", "");
			string fileName = Path.GetFileName(val.GetString("hs_store_blueprint_file", ""));
			bool num = !string.IsNullOrWhiteSpace(requestListingId) && string.Equals(@string, requestListingId, StringComparison.Ordinal);
			bool flag = !string.IsNullOrWhiteSpace(requestBlueprintFile) && string.Equals(fileName, Path.GetFileName(requestBlueprintFile), StringComparison.OrdinalIgnoreCase);
			if (!num && !flag)
			{
				return false;
			}
			name = val.GetString("hs_store_blueprint_name", "");
			blueprintFile = fileName;
			return !string.IsNullOrWhiteSpace(blueprintFile);
		}

		private void TryClaimLocalPreview()
		{
			if (ZoneBlueprintStorePreviewPayload.CanCreateLocalPreview && !_ownedPreview.HasRoot && (string.Equals(_cachedMode, "buy", StringComparison.Ordinal) || string.Equals(_cachedMode, "price", StringComparison.Ordinal)))
			{
				if (!ZoneBlueprintStorePreviewTool.TryTransferPreviewToChest(_cachedMode, _cachedListingId, _cachedBlueprintName, ((Component)this).transform, out GameObject root, out Material material))
				{
					TryRestoreLocalPreview();
					return;
				}
				if ((Object)(object)root == (Object)null)
				{
					TryRestoreLocalPreview();
					return;
				}
				_ownedPreview.Adopt(root, material);
				_previewRestoreRequested = false;
			}
		}

		private void TryRestoreLocalPreview()
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: 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)
			if (_ownedPreview.HasRoot)
			{
				return;
			}
			ZDO val = (((Object)(object)_nview != (Object)null && _nview.IsValid()) ? _nview.GetZDO() : null);
			if (val != null && ZoneBlueprintStorePreviewPayload.TryRead(val, val.GetString("hs_store_blueprint_file", ""), out var descriptor))
			{
				ZoneBlueprintFile blueprint3;
				if (ZoneBlueprintStoreDraftRepository.TryLoadBlueprintFile(descriptor.BlueprintFile, out ZoneBlueprintFile blueprint, out string _))
				{
					ZoneBlueprintFile blueprint2 = ZoneBlueprintStorePreviewPayload.CreatePreviewBlueprint(blueprint);
					CachePreviewRestoreBlueprint(descriptor.BlueprintFile, blueprint2);
					CreateOwnedPreview(blueprint2, descriptor.Anchor, descriptor.Rotation);
				}
				else if (TryGetCachedPreviewRestoreBlueprint(descriptor.BlueprintFile, out blueprint3))
				{
					CreateOwnedPreview(blueprint3, descriptor.Anchor, descriptor.Rotation);
				}
				else if (!_previewRestoreRequested && !IsPreviewRestorePending(descriptor.BlueprintFile))
				{
					_previewRestoreRequested = true;
					MarkPreviewRestorePending(descriptor.BlueprintFile);
					ZoneBlueprintStore.RequestPreviewRestore(_cachedMode, _cachedListingId, _cachedBlueprintName, descriptor.BlueprintFile);
				}
			}
		}

		private void CreateOwnedPreview(ZoneBlueprintFile blueprint, Vector3 anchor, Quaternion rotation)
		{
			//IL_0017: 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_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			_ownedPreview.CreateBlueprint(blueprint, "HomesteadStoreChestPreview_" + _cachedBlueprintName, anchor, rotation);
			Color color = (string.Equals(_cachedMode, "buy", StringComparison.Ordinal) ? BlueprintConfig.StorePurchasePreviewColor : BlueprintConfig.StoreListingPreviewColor);
			_ownedPreview.ApplyMaterial(color);
			_previewRestoreRequested = false;
		}

		internal static void HandlePreviewRestoreResponse(ZoneBlueprintStorePreviewRestoreResponse response)
		{
			ClearPreviewRestorePending(response.BlueprintFile);
			ZoneBlueprintStoreChest[] array = Object.FindObjectsByType<ZoneBlueprintStoreChest>((FindObjectsSortMode)0);
			for (int i = 0; i < array.Length; i++)
			{
				array[i].TryApplyPreviewRestoreResponse(response);
			}
		}

		private void TryApplyPreviewRestoreResponse(ZoneBlueprintStorePreviewRestoreResponse response)
		{
			//IL_00ff: 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)
			if (_ownedPreview.HasRoot)
			{
				return;
			}
			RefreshCachedIdentity();
			if (!string.Equals(_cachedMode, response.Mode, StringComparison.Ordinal))
			{
				return;
			}
			ZDO val = (((Object)(object)_nview != (Object)null && _nview.IsValid()) ? _nview.GetZDO() : null);
			if (val == null || !ZoneBlueprintStorePreviewPayload.TryRead(val, val.GetString("hs_store_blueprint_file", ""), out var descriptor))
			{
				return;
			}
			bool num = !string.IsNullOrWhiteSpace(response.ListingId) && string.Equals(_cachedListingId, response.ListingId, StringComparison.Ordinal);
			bool flag = !string.IsNullOrWhiteSpace(response.BlueprintFile) && string.Equals(Path.GetFileName(descriptor.BlueprintFile), Path.GetFileName(response.BlueprintFile), StringComparison.OrdinalIgnoreCase);
			if (!num && !flag)
			{
				return;
			}
			_previewRestoreRequested = false;
			if (!response.Success)
			{
				return;
			}
			try
			{
				if (ZoneBlueprintNetworkPayload.TryDeserializeBlueprintPayload(response.BlueprintPayload, response.BlueprintEncoding, out ZoneBlueprintFile blueprint, out string reason))
				{
					CachePreviewRestoreBlueprint(response.BlueprintFile, blueprint);
					CreateOwnedPreview(blueprint, descriptor.Anchor, descriptor.Rotation);
				}
				else
				{
					HomesteadPlugin.HomesteadLogger.LogWarning((object)("Failed to restore blueprint store chest preview: " + reason));
				}
			}
			catch (Exception ex)
			{
				HomesteadPlugin.HomesteadLogger.LogWarning((object)("Failed to restore blueprint store chest preview: " + ex.Message));
			}
		}

		private static bool TryGetCachedPreviewRestoreBlueprint(string blueprintFile, out ZoneBlueprintFile blueprint)
		{
			return PreviewRestoreBlueprintCache.TryGetValue(CreatePreviewRestoreCacheKey(blueprintFile), out blueprint);
		}

		private static void CachePreviewRestoreBlueprint(string blueprintFile, ZoneBlueprintFile blueprint)
		{
			string text = CreatePreviewRestoreCacheKey(blueprintFile);
			if (!string.IsNullOrWhiteSpace(text) && !PreviewRestoreBlueprintCache.ContainsKey(text))
			{
				PreviewRestoreBlueprintCache[text] = blueprint;
				PreviewRestoreBlueprintCacheOrder.Enqueue(text);
				while (PreviewRestoreBlueprintCache.Count > 32 && PreviewRestoreBlueprintCacheOrder.Count > 0)
				{
					string key = PreviewRestoreBlueprintCacheOrder.Dequeue();
					PreviewRestoreBlueprintCache.Remove(key);
				}
			}
		}

		private static bool IsPreviewRestorePending(string blueprintFile)
		{
			return PendingPreviewRestoreFiles.Contains(CreatePreviewRestoreCacheKey(blueprintFile));
		}

		private static void MarkPreviewRestorePending(string blueprintFile)
		{
			string text = CreatePreviewRestoreCacheKey(blueprintFile);
			if (!string.IsNullOrWhiteSpace(text))
			{
				PendingPreviewRestoreFiles.Add(text);
			}
		}

		private static void ClearPreviewRestorePending(string blueprintFile)
		{
			string text = CreatePreviewRestoreCacheKey(blueprintFile);
			if (!string.IsNullOrWhiteSpace(text))
			{
				PendingPreviewRestoreFiles.Remove(text);
			}
		}

		private static string CreatePreviewRestoreCacheKey(string blueprintFile)
		{
			return Path.GetFileName(blueprintFile ?? "");
		}

		private bool IsPriceMode()
		{
			ZNetView? nview = _nview;
			object a;
			if (nview == null)
			{
				a = null;
			}
			else
			{
				ZDO zDO = nview.GetZDO();
				a = ((zDO != null) ? zDO.GetString("hs_store_mode", "") : null);
			}
			return string.Equals((string?)a, "price", StringComparison.Ordinal);
		}

		private bool IsPurchaseMode()
		{
			ZNetView? nview = _nview;
			object a;
			if (nview == null)
			{
				a = null;
			}
			else
			{
				ZDO zDO = nview.GetZDO();
				a = ((zDO != null) ? zDO.GetString("hs_store_mode", "") : null);
			}
			return string.Equals((string?)a, "buy", StringComparison.Ordinal);
		}

		private bool IsPayoutMode()
		{
			ZNetView? nview = _nview;
			object a;
			if (nview == null)
			{
				a = null;
			}
			else
			{
				ZDO zDO = nview.GetZDO();
				a = ((zDO != null) ? zDO.GetString("hs_store_mode", "") : null);
			}
			return string.Equals((string?)a, "payout", StringComparison.Ordinal);
		}

		private List<ZoneBlueprintStorePriceItem> GetPriceItems()
		{
			ZNetView? nview = _nview;
			object obj;
			if (nview == null)
			{
				obj = null;
			}
			else
			{
				ZDO zDO = nview.GetZDO();
				obj = ((zDO != null) ? zDO.GetString("hs_store_price_payload", "") : null);
			}
			if (obj == null)
			{
				obj = "";
			}
			return ZoneBlueprintStore.DeserializePriceItems((string)obj);
		}

		private List<ZoneBlueprintRequirement> GetPriceRequirements()
		{
			return ZoneMaterialEscrow.ToRequirements(GetPriceItems());
		}

		private int GetPurchaseDeposited(string itemName)
		{
			string itemName2 = itemName;
			return (from item in GetDepositedPriceItems()
				where string.Equals(item.ItemName, itemName2, StringComparison.Ordinal)
				select item).Sum((ZoneBlueprintStorePriceItem item) => item.Amount);
		}

		private void AbsorbPurchaseInventoryMaterials()
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			if (_container?.m_inventory != null && _container.m_inventory.GetAllItems().ToList().Count != 0 && CreatePurchaseEscrow().AbsorbUnexpectedInventoryItems(_container.m_inventory, ((Component)this).transform.position, preferInventory: false).Changed)
			{
				_container.Save();
				Touch();
			}
		}

		private string FormatDeposited(IEnumerable<ZoneBlueprintStorePriceItem> priceItems)
		{
			return FormatDeposited(ZoneMaterialEscrow.ToRequirements(priceItems));
		}

		private string FormatDeposited(IEnumerable<ZoneBlueprintRequirement> requirements)
		{
			return CreatePurchaseEscrow(requirements).FormatDeposited();
		}

		private List<ZoneBlueprintStorePriceItem> GetDepositedPriceItems()
		{
			ZNetView? nview = _nview;
			object obj;
			if (nview == null)
			{
				obj = null;
			}
			else
			{
				ZDO zDO = nview.GetZDO();
				obj = ((zDO != null) ? zDO.GetString("hs_store_purchase_deposit_payload", "") : null);
			}
			if (obj == null)
			{
				obj = "";
			}
			return ZoneBlueprintStore.DeserializePriceItems((string)obj);
		}

		private static List<ZoneBlueprintStorePriceItem> GetDepositedPriceItems(ZDO? zdo)
		{
			return ZoneBlueprintStore.DeserializePriceItems(((zdo != null) ? zdo.GetString("hs_store_purchase_deposit_payload", "") : null) ?? "");
		}

		private void SetDepositedPriceItems(IReadOnlyList<ZoneBlueprintStorePriceItem> priceItems)
		{
			ZNetView? nview = _nview;
			if (nview != null)
			{
				ZDO zDO = nview.GetZDO();
				if (zDO != null)
				{
					zDO.Set("hs_store_purchase_deposit_payload", ZoneBlueprintStore.SerializePriceItems(priceItems));
				}
			}
		}

		private static void SetDepositedPriceItems(ZDO? zdo, IReadOnlyList<ZoneBlueprintStorePriceItem> priceItems)
		{
			if (zdo != null)
			{
				zdo.Set("hs_store_purchase_deposit_payload", ZoneBlueprintStore.SerializePriceItems(priceItems));
			}
		}

		private static int GetPurchaseDeposited(ZDO? zdo, string itemName)
		{
			string itemName2 = itemName;
			return (from item in GetDepositedPriceItems(zdo)
				where string.Equals(item.ItemName, itemName2, StringComparison.Ordinal)
				select item).Sum((ZoneBlueprintStorePriceItem item) => item.Amount);
		}

		private void AddPurchaseDeposit(ZoneBlueprintRequirement requirement, int amount)
		{
			ZoneBlueprintRequirement requirement2 = requirement;
			if (amount <= 0)
			{
				return;
			}
			List<ZoneBlueprintStorePriceItem> depositedPriceItems = GetDepositedPriceItems();
			ZoneBlueprintStorePriceItem zoneBlueprintStorePriceItem = depositedPriceItems.FirstOrDefault((ZoneBlueprintStorePriceItem item) => string.Equals(item.ItemName, requirement2.ItemName, StringComparison.Ordinal));
			if (zoneBlueprintStorePriceItem == null)
			{
				depositedPriceItems.Add(new ZoneBlueprintStorePriceItem
				{
					ItemName = requirement2.ItemName,
					PrefabName = requirement2.PrefabName,
					DisplayName = requirement2.DisplayName,
					Amount = amount
				});
			}
			else
			{
				zoneBlueprintStorePriceItem.Amount += amount;
				if (string.IsNullOrWhiteSpace(zoneBlueprintStorePriceItem.PrefabName))
				{
					zoneBlueprintStorePriceItem.PrefabName = requirement2.PrefabName;
				}
				if (string.IsNullOrWhiteSpace(zoneBlueprintStorePriceItem.DisplayName))
				{
					zoneBlueprintStorePriceItem.DisplayName = requirement2.DisplayName;
				}
			}
			SetDepositedPriceItems(ZoneBlueprintStore.NormalizePriceItems(depositedPriceItems));
		}

		private ZoneBlueprintStorePurchaseEscrow CreatePurchaseEscrow()
		{
			return CreatePurchaseEscrow(GetPriceRequirements());
		}

		private ZoneBlueprintStorePurchaseEscrow CreatePurchaseEscrow(IEnumerable<ZoneBlueprintRequirement> requirements)
		{
			IEnumerable<ZoneBlueprintRequirement> requirements2 = requirements;
			return new ZoneBlueprintStorePurchaseEscrow((Component)(object)this, () => requirements2, GetPurchaseDeposited, AddPurchaseDeposit);
		}

		private static ZoneMaterialEscrow.Session CreatePurchaseEscrow(ZDO? zdo, IEnumerable<ZoneBlueprintRequirement> requirements)
		{
			ZDO zdo2 = zdo;
			return new ZoneMaterialEscrow.Session(requirements, (string itemName) => GetPurchaseDeposited(zdo2, itemName), delegate
			{
			});
		}

		private static Sprite? GetRequirementIcon(ZoneBlueprintRequirement requirement)
		{
			GameObject val = ZoneBlueprintStore.FindItemPrefab(requirement.PrefabName);
			ItemDrop val2 = (((Object)(object)val != (Object)null) ? val.GetComponent<ItemDrop>() : null);
			if (!((Object)(object)val2 != (Object)null))
			{
				return null;
			}
			return val2.m_itemData.GetIcon();
		}

		private static string FormatShortcut(KeyboardShortcut shortcut)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			string text = ConfigValueHelpers.FormatShortcut(shortcut);
			if (!string.Equals(text, "None", StringComparison.OrdinalIgnoreCase))
			{
				return text;
			}
			return "Unbound";
		}

		private void OnDestroy()
		{
			ReleaseAzuCraftyBoxesContainer("StoreChest.OnDestroy");
			ZDO val = (((Object)(object)_nview != (Object)null && _nview.IsValid()) ? _nview.GetZDO() : null);
			if (val != null)
			{
				_cachedMode = val.GetString("hs_store_mode", _cachedMode);
				_cachedListingId = val.GetString("hs_store_listing", _cachedListingId);
				_cachedBlueprintName = val.GetString("hs_store_blueprint_name", _cachedBlueprintName);
			}
			DestroyOwnedPreview();
			ZoneBlueprintStoreChestRegistry.Unregister(this);
			ZoneBlueprintStorePreviewTool.NotifyStoreChestDestroyed(_cachedMode, _cachedListingId, _cachedBlueprintName);
		}

		private void DestroyOwnedPreview()
		{
			_ownedPreview.Destroy();
		}
	}
	[HarmonyPatch(typeof(WearNTear), "Destroy")]
	internal static class ZoneBlueprintStoreWearNTearDestroyPatch
	{
		private static void Prefix(WearNTear __instance)
		{
			ZoneBlueprintStoreChest component = ((Component)__instance).GetComponent<ZoneBlueprintStoreChest>();
			if (!((Object)(object)component == (Object)null))
			{
				component.ReleaseAzuCraftyBoxesContainer("StoreChest.WearNTear.Destroy");
				component.CleanupOwnedDraftFile("WearNTear.Destroy");
			}
		}
	}
	[HarmonyPatch(typeof(ZNetScene), "Destroy")]
	internal static class ZoneBlueprintStoreZNetSceneDestroyPatch
	{
		private static void Prefix(GameObject go)
		{
			if (Object.op_Implicit((Object)(object)go))
			{
				ZoneBlueprintStoreChest component = go.GetComponent<ZoneBlueprintStoreChest>();
				if (!((Object)(object)component == (Object)null))
				{
					component.ReleaseAzuCraftyBoxesContainer("StoreChest.ZNetScene.Destroy");
					component.CleanupOwnedDraftFile("ZNetScene.Destroy");
				}
			}
		}
	}
	internal static class ZoneBlueprintStoreChestPatchHelper
	{
		public static bool TryGetStoreChest(Container? container, out ZoneBlueprintStoreChest chest)
		{
			chest = null;
			if (!Object.op_Implicit((Object)(object)container))
			{
				return false;
			}
			chest = ((Component)container).GetComponent<ZoneBlueprintStoreChest>();
			return (Object)(object)chest != (Object)null;
		}

		public static bool TryGetPurchaseChest(Container? container, out ZoneBlueprintStoreChest chest)
		{
			chest = null;
			if (TryGetStoreChest(container, out chest))
			{
				return chest.IsPurchaseChest();
			}
			return false;
		}

		public static bool TryGetPayoutChest(Container? container, out ZoneBlueprintStoreChest chest)
		{
			chest = null;
			if (TryGetStoreChest(container, out chest))
			{
				return chest.IsPayoutChest();
			}
			return false;
		}

		public static void MessagePayoutDepositBlocked()
		{
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer != null)
			{
				((Character)localPlayer).Message((MessageType)1, HomesteadLocalization.Text("hs_store_payout_withdrawals_only"), 0, (Sprite)null);
			}
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "OnSelectedItem")]
	internal static class ZoneBlueprintStorePayoutInventorySelectedPatch
	{
		private static bool Prefix(InventoryGui __instance, InventoryGrid grid, ItemData item, Vector2i pos, Modifier mod)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Invalid comparison between Unknown and I4
			if ((Object)(object)__instance == (Object)null || (Object)(object)grid == (Object)null || !ZoneBlueprintStoreChestPatchHelper.TryGetPayoutChest(__instance.m_currentContainer, out ZoneBlueprintStoreChest _))
			{
				return true;
			}
			Inventory inventory = __instance.m_currentContainer.GetInventory();
			bool flag = grid.GetInventory() == inventory;
			if (Object.op_Implicit((Object)(object)__instance.m_dragGo))
			{
				if (flag && __instance.m_dragInventory != inventory)
				{
					ZoneBlueprintStoreChestPatchHelper.MessagePayoutDepositBlocked();
					return false;
				}
				return true;
			}
			if (item == null)
			{
				return true;
			}
			if ((int)mod == 2 && !flag)
			{
				ZoneBlueprintStoreChestPatchHelper.MessagePayoutDepositBlocked();
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Container), "Interact")]
	internal static class ZoneBlueprintStoreChestContainerPatch
	{
		private static bool Prefix(Container __instance, Humanoid character, bool hold, ref bool __result)
		{
			//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)
			ZoneBlueprintStoreChest component = ((Component)__instance).GetComponent<ZoneBlueprintStoreChest>();
			if (!((Object)(object)component == (Object)null || hold))
			{
				Player val = (Player)(object)((character is Player) ? character : null);
				if (val != null)
				{
					KeyboardShortcut chestConfirmHotkey = BlueprintConfig.ChestConfirmHotkey;
					if (((KeyboardShortcut)(ref chestConfirmHotkey)).IsDown())
					{
						__result = component.TryConfirm(val);
						return false;
					}
					if (component.IsPriceChest())
					{
						ZoneBlueprintStorePriceEditorUi.Open(component);
						component.Touch();
						__result = true;
						return false;
					}
					if (component.IsPurchaseChest() && BlueprintConfig.AzuCraftyBoxesPullOnOpen)
					{
						component.TryPullAvailableMaterials(val, "open", message: true);
					}
					component.Touch();
					return true;
				}
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Container), "GetHoverText")]
	internal static class ZoneBlueprintStoreChestHoverPatch
	{
		private static bool Prefix(Container __instance, ref string __result)
		{
			ZoneBlueprintStoreChest component = ((Component)__instance).GetComponent<ZoneBlueprintStoreChest>();
			if ((Object)(object)component == (Object)null)
			{
				return true;
			}
			__result = component.GetHoverText();
			return false;
		}
	}
	[HarmonyPatch(typeof(InventoryGrid), "UpdateGui")]
	internal static class ZoneBlueprintStoreInventoryGridUpdateGuiPatch
	{
		private static void Postfix(InventoryGrid __instance)
		{
			ZoneBlueprintChestInventoryScroll.TryKeepContainerGridAtTop(__instance);
			InventoryGui instance = InventoryGui.instance;
			if (!((Object)(object)instance == (Object)null) && !((Object)(object)instance.m_containerGrid != (Object)(object)__instance) && ZoneBlueprintStoreChestPatchHelper.TryGetPurchaseChest(instance.m_currentContainer, out ZoneBlueprintStoreChest chest))
			{
				chest.DrawRequirementOverlay(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "OnSelectedItem")]
	internal static class ZoneBlueprintStoreInventorySelectedPatch
	{
		private static bool Prefix(InventoryGui __instance, InventoryGrid grid, ItemData item, Vector2i pos, Modifier mod)
		{
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Invalid comparison between Unknown and I4
			if ((Object)(object)__instance == (Object)null || (Object)(object)grid == (Object)null || !ZoneBlueprintStoreChestPatchHelper.TryGetPurchaseChest(__instance.m_currentContainer, out ZoneBlueprintStoreChest chest))
			{
				return true;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || ((Character)localPlayer).IsTeleporting())
			{
				return true;
			}
			Inventory inventory = __instance.m_currentContainer.GetInventory();
			bool flag = grid.GetInventory() == inventory;
			if (Object.op_Implicit((Object)(object)__instance.m_dragGo))
			{
				if (!flag || __instance.m_dragInventory == inventory)
				{
					return true;
				}
				if (__instance.m_dragItem != null && !__instance.m_dragItem.m_shared.m_questItem)
				{
					chest.TryAcceptPurchaseMaterialFromInventory(__instance.m_dragInventory, __instance.m_dragItem, __instance.m_dragAmount, message: true);
				}
				__instance.SetupDragItem((ItemData)null, (Inventory)null, 1);
				__instance.UpdateCraftingPanel(false);
				return false;
			}
			if (item == null)
			{
				return !flag;
			}
			if ((int)mod == 2 && !flag && !item.m_shared.m_questItem)
			{
				chest.TryAcceptPurchaseMaterialFromInventory(grid.GetInventory(), item, item.m_stack, message: true);
				__instance.UpdateCraftingPanel(false);
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "OnStackAll")]
	internal static class ZoneBlueprintStorePayoutInventoryStackAllPatch
	{
		private static bool Prefix(InventoryGui __instance)
		{
			if ((Object)(object)__instance == (Object)null || !ZoneBlueprintStoreChestPatchHelper.TryGetPayoutChest(__instance.m_currentContainer, out ZoneBlueprintStoreChest _))
			{
				return true;
			}
			ZoneBlueprintStoreChestPatchHelper.MessagePayoutDepositBlocked();
			return false;
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "OnStackAll")]
	internal static class ZoneBlueprintStoreInventoryStackAllPatch
	{
		private static bool Prefix(InventoryGui __instance)
		{
			if ((Object)(object)__instance == (Object)null || !ZoneBlueprintStoreChestPatchHelper.TryGetPurchaseChest(__instance.m_currentContainer, out ZoneBlueprintStoreChest chest) || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				return true;
			}
			__instance.SetupDragItem((ItemData)null, (Inventory)null, 1);
			chest.TryAcceptAllPurchaseMaterialsFromPlayer(Player.m_localPlayer);
			return false;
		}
	}
	[HarmonyPatch(typeof(Container), "StackAll")]
	internal static class ZoneBlueprintStorePayoutContainerStackAllPatch
	{
		private static bool Prefix(Container __instance)
		{
			if (!ZoneBlueprintStoreChestPatchHelper.TryGetPayoutChest(__instance, out ZoneBlueprintStoreChest _))
			{
				return true;
			}
			ZoneBlueprintStoreChestPatchHelper.MessagePayoutDepositBlocked();
			return false;
		}
	}
	[HarmonyPatch(typeof(Container), "StackAll")]
	internal static class ZoneBlueprintStoreContainerStackAllPatch
	{
		private static bool Prefix(Container __instance)
		{
			ZoneBlueprintStoreChest component = ((Component)__instance).GetComponent<ZoneBlueprintStoreChest>();
			if ((Object)(object)component == (Object)null || !component.IsPurchaseChest() || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				return true;
			}
			component.TryAcceptAllPurchaseMaterialsFromPlayer(Player.m_localPlayer);
			return false;
		}
	}
	internal static class ZoneBlueprintStoreChestPrefab
	{
		private sealed class ChestPrefabDefinition
		{
			public string PrefabName { get; }

			public string BasePrefabName { get; }

			public string DisplayName { get; }

			public string Description { get; }

			public int Width { get; }

			public int Height { get; }

			public PrivacySetting Privacy { get; }

			public int PrefabHash { get; }

			public bool Registered { get; set; }

			public ChestPrefabDefinition(string prefabName, string basePrefabName, string displayName, string description, int width, int height, PrivacySetting privacy)
			{
				//IL_0034: 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)
				PrefabName = prefabName;
				BasePrefabName = basePrefabName;
				DisplayName = displayName;
				Description = description;
				Width = width;
				Height = height;
				Privacy = privacy;
				PrefabHash = StringExtensionMethods.GetStableHashCode(prefabName);
			}
		}

		private sealed class StoreChestPlacementRequest
		{
			public ChestPrefabDefinition Definition { get; }

			public string Mode { get; }

			public long OwnerPlayerId { get; }

			public string OwnerName { get; }

			public string OwnerPlatformId { get; }

			public Vector3 Position { get; }

			public Quaternion Rotation { get; }

			public long VfxExcludePeer { get; }

			public StoreChestPlacementRequest(ChestPrefabDefinition definition, string mode, long ownerPlayerId, string ownerName, string ownerPlatformId, Vector3 position, Quaternion rotation, long vfxExcludePeer)
			{
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: 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)
				Definition = definition;
				Mode = mode;
				OwnerPlayerId = ownerPlayerId;
				OwnerName = ownerName;
				OwnerPlatformId = ownerPlatformId;
				Position = position;
				Rotation = rotation;
				VfxExcludePeer = vfxExcludePeer;
			}
		}

		internal const string PricePrefabName = "piece_chest_barrel_blueprint_store_price";

		internal const string PurchasePrefabName = "piece_chest_blueprint_store_purchase";

		internal const string PayoutPrefabName = "piece_chest_blackmetal_blueprint_store_payout";

		private const string PriceBasePrefabName = "piece_chest_barrel";

		private const string PurchaseBasePrefabName = "piece_chest";

		private const string PayoutBasePrefabName = "piece_chest_blackmetal";

		internal static readonly int PricePrefabHash = StringExtensionMethods.GetStableHashCode("piece_chest_barrel_blueprint_store_price");

		internal static readonly int PurchasePrefabHash = StringExtensionMethods.GetStableHashCode("piece_chest_blueprint_store_purchase");

		internal static readonly int PayoutPrefabHash = StringExtensionMethods.GetStableHashCode("piece_chest_blackmetal_blueprint_store_payout");

		private static readonly ChestPrefabDefinition PriceChest = new ChestPrefabDefinition("piece_chest_barrel_blueprint_store_price", "piece_chest_barrel", HomesteadLocalization.Token("hs_store_price_chest_name"), HomesteadLocalization.Token("hs_store_price_chest_desc"), 8, 1, (PrivacySetting)2);

		private static readonly ChestPrefabDefinition PurchaseChest = new ChestPrefabDefinition("piece_chest_blueprint_store_purchase", "piece_chest", HomesteadLocalization.Token("hs_store_purchase_chest_name"), HomesteadLocalization.Token("hs_store_purchase_chest_desc"), 8, 1, (PrivacySetting)2);

		private static readonly ChestPrefabDefinition PayoutChest = new ChestPrefabDefinition("piece_chest_blackmetal_blueprint_store_payout", "piece_chest_blackmetal", HomesteadLocalization.Token("hs_store_payout_chest_name"), HomesteadLocalization.Token("hs_store_payout_chest_desc"), 8, 4, (PrivacySetting)0);

		private static readonly ChestPrefabDefinition[] StoreChests = new ChestPrefabDefinition[3] { PriceChest, PurchaseChest, PayoutChest };

		private static ManualLogSource? _logger;

		private static bool _initialized;

		public static void Initialize(ManualLogSource logger)
		{
			_logger = logger;
			if (!_initialized)
			{
				_initialized = true;
				PrefabManager.OnVanillaPrefabsAvailable += RegisterPrefab;
				RegisterPrefab();
			}
		}

		private static bool TryValidatePlacement(StoreChestPlacementRequest request, int requestedCount, out GameObject prefab, out HomesteadCommandResult failure)
		{
			RegisterPrefab();
			prefab = null;
			failure = HomesteadCommandResult.Fail("");
			if (!ZoneBlueprintChestLifecycle.CanPlaceChests(request.OwnerPlatformId, requestedCount, out string reason))
			{
				failure = HomesteadCommandResult.Fail(reason);
				return false;
			}
			GameObject prefab2 = GetPrefab(request.Definition);
			if (!Object.op_Implicit((Object)(object)prefab2))
			{
				failure = HomesteadCommandResult.Fail(GetPrefabNotReadyMessage(request.Mode));
				return false;
			}
			prefab = prefab2;
			return true;
		}

		private static GameObject SpawnChest(StoreChestPlacementRequest request, GameObject prefab)
		{
			//IL_0002: 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)
			GameObject obj = Object.Instantiate<GameObject>(prefab, request.Position, request.Rotation);
			ZNetView component = obj.GetComponent<ZNetView>();
			if ((Object)(object)component != (Object)null && component.IsValid())
			{
				ZDO zDO = component.GetZDO();
				zDO.Set(ZDOVars.s_creator, request.OwnerPlayerId);
				zDO.Set(ZDOVars.s_creatorName, request.OwnerName);
				ZoneBlueprintChestLifecycle.SetOwnerPlatformId(zDO, request.OwnerPlatformId);
			}
			return obj;
		}

		private static ZoneBlueprintStoreChest GetStoreChest(GameObject chest)
		{
			return chest.GetComponent<ZoneBlueprintStoreChest>() ?? chest.AddComponent<ZoneBlueprintStoreChest>();
		}

		private static void CompletePlacement(StoreChestPlacementRequest request, GameObject chest, bool broadcast)
		{
			//IL_0020: 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)
			ZoneChestPlacement.PlayPlaceEffect(chest);
			ZoneChestPlacement.SafeOnPlaced(chest, _logger, "Store chest");
			if (broadcast)
			{
				ZoneBlueprintChestVfx.BroadcastPlace(request.Mode, ToTransformPayload(request.Position, request.Rotation), request.VfxExcludePeer);
			}
		}

		private static string GetPrefabNotReadyMessage(string mode)
		{
			if (!(mode == "price"))
			{
				if (mode == "payout")
				{
					return HomesteadLocalization.Text("hs_store_payout_chest_prefab_not_ready");
				}
				return HomesteadLocalization.Text("hs_store_purchase_chest_prefab_not_ready");
			}
			return HomesteadLocalization.Text("hs_store_price_chest_prefab_not_ready");
		}

		public static HomesteadCommandResult PlacePurchaseChest(ZoneBlueprintStoreListing listing, IReadOnlyList<ZoneBlueprintStorePriceItem> priceItems, string offerId, long buyerPlayerId, string buyerName, string buyerPlatformId, Vector3 position, Quaternion rotation, Vector3 previewAnchor, Quaternion previewRotation, long vfxExcludePeer = 0L)
		{
			//IL_000f: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			StoreChestPlacementRequest request = new StoreChestPlacementRequest(PurchaseChest, "buy", buyerPlayerId, buyerName, buyerPlatformId, position, rotation, vfxExcludePeer);
			if (!TryValidatePlacement(request, 1, out GameObject prefab, out HomesteadCommandResult failure))
			{
				return failure;
			}
			GameObject chest = null;
			try
			{
				chest = SpawnChest(request, prefab);
				GetStoreChest(chest).SetPurchase(listing, priceItems, offerId, buyerPlayerId, buyerName, buyerPlatformId, previewAnchor, previewRotation);
				CompletePlacement(request, chest, broadcast: true);
				return HomesteadCommandResult.Ok(HomesteadLocalization.Format("hs_store_purchase_chest_placed", listing.Name, ZoneBlueprintStore.FormatPrice(priceItems)));
			}
			catch (Exception ex)
			{
				ZoneChestPlacement.DestroySpawned(chest);
				return HomesteadCommandResult.Fail(FormatStoreChestPlaceFailed(ex));
			}
		}

		public static HomesteadCommandResult PlacePriceChest(string listingId, string blueprintName, string blueprintFile, string iconPngBase64, int entryCount, long sellerPlayerId, string sellerName, string sellerPlatformId, Vector3 position, Quaternion rotation, Vector3 previewAnchor, Quaternion previewRotation, long vfxExcludePeer = 0L)
		{
			//IL_0010: 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_0047: 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)
			StoreChestPlacementRequest request = new StoreChestPlacementRequest(PriceChest, "price", sellerPlayerId, sellerName, sellerPlatformId, position, rotation, vfxExcludePeer);
			if (!TryValidatePlacement(request, 1, out GameObject prefab, out HomesteadCommandResult failure))
			{
				return failure;
			}
			GameObject chest = null;
			try
			{
				chest = SpawnChest(request, prefab);
				GetStoreChest(chest).SetPriceDraft(listingId, blueprintName, blueprintFile, iconPngBase64, entryCount, sellerPlayerId, sellerName, sellerPlatformId, previewAnchor, previewRotation);
				CompletePlacement(request, chest, broadcast: true);
				return HomesteadCommandResult.Ok(HomesteadLocalization.Format("hs_store_price_chest_placed", blueprintName));
			}
			catch (Exception ex)
			{
				ZoneChestPlacement.DestroySpawned(chest);
				return HomesteadCommandResult.Fail(FormatStoreChestPlaceFailed(ex));
			}
		}

		public static HomesteadCommandResult PlacePayoutChests(IReadOnlyList<ZoneBlueprintStorePriceItem> payoutItems, long sellerPlayerId, string sellerName, string sellerPlatformId, Vector3 basePosition, Quaternion rotation, bool positionIsAnchor, out List<ZoneBlueprintStoreTransformPayload> chestTransforms, long vfxExcludePeer = 0L)
		{
			//IL_004f: 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_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: 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_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_00e9: 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_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: 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_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			chestTransforms = new List<ZoneBlueprintStoreTransformPayload>();
			if (!ZoneMaterialEscrow.TrySplitIntoStacks(payoutItems, out List<ZoneBlueprintStorePriceItem> stacks, out string reason))
			{
				return HomesteadCommandResult.Fail(reason);
			}
			int num = Mathf.CeilToInt((float)stacks.Count / 32f);
			if (num <= 0)
			{
				return HomesteadCommandResult.Fail(HomesteadLocalization.Text("hs_store_no_payout_materials"));
			}
			if (!TryValidatePlacement(new StoreChestPlacementRequest(PayoutChest, "payout", sellerPlayerId, sellerName, sellerPlatformId, basePosition, rotation, vfxExcludePeer), num, out GameObject prefab, out HomesteadCommandResult failure))
			{
				return failure;
			}
			List<GameObject> list = new List<GameObject>();
			try
			{
				Vector3 val = default(Vector3);
				for (int i = 0; i < num; i++)
				{
					List<ZoneBlueprintStorePriceItem> stacks2 = stacks.Skip(i * 32).Take(32).ToList();
					float num2 = (positionIsAnchor ? 0f : 2.2f) + (float)(i / 4) * 1.8f;
					((Vector3)(ref val))..ctor((float)(i % 4) * 1.8f - (float)Mathf.Min(num - 1, 3) * 0.9f, 0f, num2);
					Vector3 val2 = basePosition + rotation * val;
					if (positionIsAnchor)
					{
						val2.y = basePosition.y;
					}
					else
					{
						val2.y = SampleGroundY(val2.x, val2.z, val2.y);
					}
					StoreChestPlacementRequest request = new StoreChestPlacementRequest(PayoutChest, "payout", sellerPlayerId, sellerName, sellerPlatformId, val2, rotation, vfxExcludePeer);
					GameObject val3 = SpawnChest(request, prefab);
					list.Add(val3);
					ZoneBlueprintStoreChest storeChest = GetStoreChest(val3);
					storeChest.SetPayout(sellerPlayerId, sellerName, sellerPlatformId);
					CompletePlacement(request, val3, broadcast: false);
					if (!storeChest.PreparePayoutInventory(stacks2))
					{
						throw new InvalidOperationException(HomesteadLocalization.Text("hs_store_payout_chest_fill_failed"));
					}
					chestTransforms.Add(ToTransformPayload(val2, rotation));
				}
			}
			catch (Exception ex)
			{
				foreach (GameObject item in list.Where((GameObject chest) => (Object)(object)chest != (Object)null && Object.op_Implicit((Object)(object)chest)))
				{
					ZoneChestPlacement.DestroySpawned(item);
				}
				return HomesteadCommandResult.Fail(HomesteadLocalization.Format("hs_store_payout_chest_place_failed", ex.Message));
			}
			ZoneBlueprintChestVfx.BroadcastPlace("payout", chestTransforms, vfxExcludePeer);
			return HomesteadCommandResult.Ok(HomesteadLocalization.Format("hs_store_payout_chest_placed", num));
		}

		private static ZoneBlueprintStoreTransformPayload ToTransformPayload(Vector3 position, Quaternion rotation)
		{
			//IL_000f: 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_0021: 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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: 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)
			ZoneBlueprintStoreTransformPayload zoneBlueprintStoreTransformPayload = new ZoneBlueprintStoreTransformPayload();
			zoneBlueprintStoreTransformPayload.Pos = new float[3] { position.x, position.y, position.z };
			zoneBlueprintStoreTransformPayload.Rot = new float[4] { rotation.x, rotation.y, rotation.z, rotation.w };
			return zoneBlueprintStoreTransformPayload;
		}

		private static string FormatStoreChestPlaceFailed(Exception ex)
		{
			return HomesteadLocalization.Format("hs_store_chest_place_failed", ex.Message);
		}

		public static GameObject? CreatePreview(string mode)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			RegisterPrefab();
			ChestPrefabDefinition definitionForMode = GetDefinitionForMode(mode);
			GameObject prefab = GetPrefab(definitionForMode);
			if (!Object.op_Implicit((Object)(object)prefab))
			{
				return null;
			}
			GameObject val = new GameObject("Homestead" + definitionForMode.PrefabName + "Preview");
			if (ZoneBlueprintVisuals.CopyVisuals(prefab.transform, val.transform) == 0)
			{
				Object.Destroy((Object)(object)val);
				return null;
			}
			return val;
		}

		public static bool PlayPlaceEffect(string mode, Vector3 position, Quaternion rotation)
		{
			//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)
			RegisterPrefab();
			return ZoneChestPlacement.PlayPlaceEffect(GetPrefab(GetDefinitionForMode(mode)), position, rotation);
		}

		internal static Sprite? GetIconForPrefabHash(int prefabHash)
		{
			RegisterPrefab();
			ChestPrefabDefinition chestPrefabDefinition = StoreChests.FirstOrDefault((ChestPrefabDefinition item) => item.PrefabHash == prefabHash);
			if (chestPrefabDefinition != null)
			{
				GameObject? prefab = GetPrefab(chestPrefabDefinition);
				if (prefab == null)
				{
					return null;
				}
				return prefab.GetComponent<Piece>()?.m_icon;
			}
			return null;
		}

		public static bool IsStorePrefab(int prefabHash)
		{
			return StoreChests.Any((ChestPrefabDefinition definition) => definition.PrefabHash == prefabHash);
		}

		public static bool IsStorePrefabName(string prefabName)
		{
			string prefabName2 = prefabName;
			return StoreChests.Any((ChestPrefabDefinition definition) => string.Equals(definition.PrefabName, prefabName2, StringComparison.OrdinalIgnoreCase));
		}

		private static GameObject? GetPrefab(ChestPrefabDefinition definition)
		{
			GameObject prefab = PrefabManager.Instance.GetPrefab(definition.PrefabName);
			if (prefab == null)
			{
				ZNetScene instance = ZNetScene.instance;
				if (instance == null)
				{
					return null;
				}
				prefab = instance.GetPrefab(definition.PrefabName);
			}
			return prefab;
		}

		private static float SampleGroundY(float x, float z, float fallbackY)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ZoneSystem.instance == (Object)null)
			{
				return fallbackY;
			}
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(x, fallbackY, z);
			Vector3 val2 = default(Vector3);
			Biome val3 = default(Biome);
			BiomeArea val4 = default(BiomeArea);
			Heightmap val5 = default(Heightmap);
			ZoneSystem.instance.GetGroundData(ref val, ref val2, ref val3, ref val4, ref val5);
			return val.y;
		}

		private static void RegisterPrefab()
		{
			ChestPrefabDefinition[] storeChests = StoreChests;
			for (int i = 0; i < storeChests.Length; i++)
			{
				RegisterPrefab(storeChests[i]);
			}
		}

		private static void RegisterPrefab(ChestPrefabDefinition definition)
		{
			if (definition.Registered)
			{
				return;
			}
			if (Object.op_Implicit((Object)(object)PrefabManager.Instance.GetPrefab(definition.PrefabName)))
			{
				definition.Registered = true;
				return;
			}
			if (!Object.op_Implicit((Object)(object)PrefabManager.Instance.GetPrefab(definition.BasePrefabName)))
			{
				ZNetScene instance = ZNetScene.instance;
				if (!Object.op_Implicit((Object)(object)((instance != null) ? instance.GetPrefab(definition.BasePrefabName) : null)))
				{
					return;
				}
			}
			GameObject val = PrefabManager.Instance.CreateClonedPrefab(definition.PrefabName, definition.BasePrefabName);
			if (Object.op_Implicit((Object)(object)val))
			{
				ConfigurePrefab(val, definition);
				PrefabManager.Instance.AddPrefab(val);
				PrefabManager.Instance.RegisterToZNetScene(val);
				definition.Registered = true;
				ManualLogSource? logger = _logger;
				if (logger != null)
				{
					logger.LogInfo((object)("Registered Homestead blueprint store chest prefab: " + definition.PrefabName + "."));
				}
			}
		}

		private static ChestPrefabDefinition GetDefinitionForMode(string mode)
		{
			if (!(mode == "price"))
			{
				if (mode == "payout")
				{
					return PayoutChest;
				}
				return PurchaseChest;
			}
			return PriceChest;
		}

		private static void ConfigurePrefab(GameObject prefab, ChestPrefabDefinition definition)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			Container component = prefab.GetComponent<Container>();
			if ((Object)(object)component != (Object)null)
			{
				component.m_name = definition.DisplayName;
				component.m_width = definition.Width;
				component.m_height = definition.Height;
				component.m_autoDestroyEmpty = false;
				component.m_privacy = definition.Privacy;
				component.m_defaultItems = new DropTable();
			}
			Piece component2 = prefab.GetComponent<Piece>();
			if ((Object)(object)component2 != (Object)null)
			{
				component2.m_name = definition.DisplayName;
				component2.m_description = definition.Description;
				component2.m_resources = Array.Empty<Requirement>();
			}
			if ((Object)(object)prefab.GetComponent<ZoneBlueprintStoreChest>() == (Object)null)
			{
				prefab.AddComponent<ZoneBlueprintStoreChest>();
			}
		}
	}
	internal static class ZoneBlueprintStoreChestRegistry
	{
		private readonly struct Key : IEquatable<Key>
		{
			public string Mode { get; }

			public string ListingId { get; }

			public string IdentityKey { get; }

			public Key(string mode, string listingId, string identityKey)
			{
				Mode = mode ?? "";
				ListingId = listingId ?? "";
				IdentityKey = identityKey ?? "";
			}

			public bool Equals(Key other)
			{
				if (string.Equals(IdentityKey, other.IdentityKey, StringComparison.Ordinal) && string.Equals(Mode, other.Mode, StringComparison.Ordinal))
				{
					return string.Equals(ListingId, other.ListingId, StringComparison.Ordinal);
				}
				return false;
			}

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

			public override int GetHashCode()
			{
				return (((StringComparer.Ordinal.GetHashCode(Mode) * 397) ^ StringComparer.Ordinal.GetHashCode(ListingId)) * 397) ^ StringComparer.Ordinal.GetHashCode(IdentityKey);
			}
		}

		[CompilerGenerated]
		private sealed class <EnumerateModeChests>d__17 : IEnumerable<ZoneBlueprintStoreChest>, IEnumerable, IEnumerator<ZoneBlueprintStoreChest>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private ZoneBlueprintStoreChest <>2__current;

			private int <>l__initialThreadId;

			private string mode;

			public string <>3__mode;

			private Key[] <>7__wrap1;

			private int <>7__wrap2;

			private ZoneBlueprintStoreChest[] <>7__wrap3;

			private int <>7__wrap4;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					goto IL_00bb;
				}
				<>1__state = -1;
				<>7__wrap1 = ByKey.Keys.ToArray();
				<>7__wrap2 = 0;
				goto IL_00ee;
				IL_00ee:
				if (<>7__wrap2 < <>7__wrap1.Length)
				{
					Key key = <>7__wrap1[<>7__wrap2];
					if (string.Equals(key.Mode, mode, StringComparison.Ordinal) && ByKey.TryGetValue(key, out HashSet<ZoneBlueprintStoreChest> value))
					{
						<>7__wrap3 = value.ToArray();
						<>7__wrap4 = 0;
						goto IL_00c9;
					}
					goto IL_00e0;
				}
				<>7__wrap1 = null;
				return false;
				IL_00c9:
				if (<>7__wrap4 < <>7__wrap3.Length)
				{
					ZoneBlueprintStoreChest zoneBlueprintStoreChest = <>7__wrap3[<>7__wrap4];
					if (!Object.op_Implicit((Object)(object)zoneBlueprintStoreChest))
					{
						Unregister(zoneBlueprintStoreChest);
						goto IL_00bb;
					}
					<>2__current = zoneBlueprintStoreChest;
					<>1__state = 1;
					return true;
				}
				<>7__wrap3 = null;
				goto IL_00e0;
				IL_00e0:
				<>7__wrap2++;
				goto IL_00ee;
				IL_00bb:
				<>7__wrap4++;
				goto IL_00c9;
			}

			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<ZoneBlueprintStoreChest> IEnumerable<ZoneBlueprintStoreChest>.GetEnumerator()
			{
				<EnumerateModeChests>d__17 <EnumerateModeChests>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<EnumerateModeChests>d__ = this;
				}
				else
				{
					<EnumerateModeChests>d__ = new <EnumerateModeChests>d__17(0);
				}
				<EnumerateModeChests>d__.mode = <>3__mode;
				return <EnumerateModeChests>d__;
			}

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

		private static readonly Dictionary<Key, HashSet<ZoneBlueprintStoreChest>> ByKey = new Dictionary<Key, HashSet<ZoneBlueprintStoreChest>>();

		private static readonly Dictionary<ZoneBlueprintStoreChest, Key> ChestKeys = new Dictionary<ZoneBlueprintStoreChest, Key>();

		public static void Refresh(ZoneBlueprintStoreChest chest)
		{
			Unregister(chest);
			if (Object.op_Implicit((Object)(object)chest) && chest.TryGetStoreLookup(out string mode, out string listingId, out ZoneBlueprintStoreActor actor))
			{
				Key key = new Key(mode, listingId, actor.Key(BlueprintConfig.StoreIdentityMode));
				if (!ByKey.TryGetValue(key, out HashSet<ZoneBlueprintStoreChest> value))
				{
					value = new HashSet<ZoneBlueprintStoreChest>();
					ByKey[key] = value;
				}
				value.Add(chest);
				ChestKeys[chest] = key;
			}
		}

		public static void Unregister(ZoneBlueprintStoreChest? chest)
		{
			if ((Object)(object)chest == (Object)null || !Object.op_Implicit((Object)(object)chest) || !ChestKeys.TryGetValue(chest, out var value))
			{
				return;
			}
			ChestKeys.Remove(chest);
			if (ByKey.TryGetValue(value, out HashSet<ZoneBlueprintStoreChest> value2))
			{
				value2.Remove(chest);
				if (value2.Count == 0)
				{
					ByKey.Remove(value);
				}
			}
		}

		public static ZoneBlueprintStoreChest? FindPurchaseChest(string listingId, ZoneBlueprintStoreActor buyer, string offerId = "")
		{
			return Find("buy", listingId, buyer, offerId);
		}

		public static ZoneBlueprintStoreChest? FindPriceChest(string listingId, ZoneBlueprintStoreActor seller)
		{
			return Find("price", listingId, seller);
		}

		public static bool TryFindPriceChestZdo(string listingId, ZoneBlueprintStoreActor seller, out ZDO? zdo)
		{
			return TryFindChestZdo("price", listingId, seller, "", out zdo);
		}

		public static bool TryFindPurchaseChestZdo(string listingId, ZoneBlueprintStoreActor buyer, string offerId, out ZDO? zdo)
		{
			return TryFindChestZdo("buy", listingId, buyer, offerId, out zdo);
		}

		private static bool TryFindChestZdo(string mode, string listingId, ZoneBlueprintStoreActor actor, string offerId, out ZDO? zdo)
		{
			zdo = null;
			foreach (ZDO item in ZoneBlueprintChestZdoRegistry.EnumerateChestZdos())
			{
				if (item != null && MatchesZdo(item, mode, listingId, actor, offerId))
				{
					zdo = item;
					return true;
				}
			}
			return false;
		}

		public static bool TryResolvePriceDraftRestore(string listingId, string blueprintFile, out string name, out string resolvedBlueprintFile)
		{
			name = "";
			resolvedBlueprintFile = "";
			foreach (ZoneBlueprintStoreChest item in EnumerateModeChests("price"))
			{
				if (item.TryResolvePriceDraftRestore(listingId, blueprintFile, out name, out resolvedBlueprintFile))
				{
					return true;
				}
			}
			foreach (ZDO item2 in ZoneBlueprintChestZdoRegistry.EnumerateChestZdos())
			{
				if (TryResolvePriceDraftRestore(item2, listingId, blueprintFile, out name, out resolvedBlueprintFile))
				{
					return true;
				}
			}
			return false;
		}

		private static ZoneBlueprintStoreChest? Find(string mode, string listingId, ZoneBlueprintStoreActor actor, string offerId = "")
		{
			Key key = new Key(mode, listingId, actor.Key(BlueprintConfig.StoreIdentityMode));
			if (!ByKey.TryGetValue(key, out HashSet<ZoneBlueprintStoreChest> value))
			{
				return FindLoadedChest(mode, listingId, actor, offerId) ?? FindZdoBackedChest(mode, listingId, actor, offerId);
			}
			ZoneBlueprintStoreChest[] array = value.ToArray();
			foreach (ZoneBlueprintStoreChest zoneBlueprintStoreChest in array)
			{
				if (!Object.op_Implicit((Object)(object)zoneBlueprintStoreChest))
				{
					Unregister(zoneBlueprintStoreChest);
					continue;
				}
				if (MatchesChest(zoneBlueprintStoreChest, mode, listingId, actor, offerId))
				{
					return zoneBlueprintStoreChest;
				}
				Refresh(zoneBlueprintStoreChest);
			}
			return FindLoadedChest(mode, listingId, actor, offerId) ?? FindZdoBackedChest(mode, listingId, actor, offerId);
		}

		private static ZoneBlueprintStoreChest? FindLoadedChest(string mode, string listingId, ZoneBlueprintStoreActor actor, string offerId)
		{
			ZoneBlueprintStoreChest[] array = Object.FindObjectsByType<ZoneBlueprintStoreChest>((FindObjectsSortMode)0);
			foreach (ZoneBlueprintStoreChest zoneBlueprintStoreChest in array)
			{
				if (MatchesChest(zoneBlueprintStoreChest, mode, listingId, actor, offerId))
				{
					Refresh(zoneBlueprintStoreChest);
					return zoneBlueprintStoreChest;
				}
			}
			return null;
		}

		private static ZoneBlueprintStoreChest? FindZdoBackedChest(string mode, string listingId, ZoneBlueprintStoreActor actor, string offerId)
		{
			if ((Object)(object)ZNetScene.instance == (Object)null)
			{
				return null;
			}
			foreach (ZDO item in ZoneBlueprintChestZdoRegistry.EnumerateChestZdos())
			{
				if (!MatchesZdo(item, mode, listingId, actor, offerId))
				{
					continue;
				}
				ZNetView val = ZNetScene.instance.FindInstance(item);
				if (!((Object)(object)val == (Object)null))
				{
					ZoneBlueprintStoreChest zoneBlueprintStoreChest = ((Component)val).GetComponent<ZoneBlueprintStoreChest>() ?? ((Component)val).gameObject.AddComponent<ZoneBlueprintStoreChest>();
					if (MatchesChest(zoneBlueprintStoreChest, mode, listingId, actor, offerId))
					{
						Refresh(zoneBlueprintStoreChest);
						return zoneBlueprintStoreChest;
					}
				}
			}
			return null;
		}

		private static bool MatchesChest(ZoneBlueprintStoreChest chest, string mode, string listingId, ZoneBlueprintStoreActor actor, string offerId)
		{
			if (Object.op_Implicit((Object)(object)chest) && chest.TryGetStoreLookup(out string mode2, out string listingId2, out ZoneBlueprintStoreActor actor2) && string.Equals(mode2, mode, StringComparison.Ordinal) && string.Equals(listingId2, listingId, StringComparison.Ordinal) && actor.MatchesStored(actor2.PlayerId, actor2.PlatformId, BlueprintConfig.StoreIdentityMode))
			{
				return MatchesOfferId(mode, chest.GetOfferId(), offerId);
			}
			return false;
		}

		private static bool MatchesZdo(ZDO zdo, string mode, string listingId, ZoneBlueprintStoreActor actor, string offerId)
		{
			if (zdo == null || !zdo.IsValid() || zdo.GetBool("hs_store_confirmed", false))
			{
				return false;
			}
			if (!string.Equals(zdo.GetString("hs_store_mode", ""), mode, StringComparison.Ordinal) || !string.Equals(zdo.GetString("hs_store_listing", ""), listingId, StringComparison.Ordinal))
			{
				return false;
			}
			long storedPlayerId = (string.Equals(mode, "buy", StringComparison.Ordinal) ? zdo.GetLong("hs_store_buyer", 0L) : zdo.GetLong("hs_store_seller", 0L));
			string ownerPlatformId = ZoneBlueprintChestLifecycle.GetOwnerPlatformId(zdo);
			if (!actor.MatchesStored(storedPlayerId, ownerPlatformId, BlueprintConfig.StoreIdentityMode))
			{
				return false;
			}
			return MatchesOfferId(mode, zdo.GetString("hs_store_offer", ""), offerId);
		}

		private static bool MatchesOfferId(string mode, string currentOfferId, string requestedOfferId)
		{
			if (!string.Equals(mode, "buy", StringComparison.Ordinal))
			{
				return true;
			}
			return string.Equals(currentOfferId ?? "", requestedOfferId ?? "", StringComparison.Ordinal);
		}

		private static bool TryResolvePriceDraftRestore(ZDO zdo, string requestListingId, string requestBlueprintFile, out string name, out string blueprintFile)
		{
			name = "";
			blueprintFile = "";
			if (zdo == null || !zdo.IsValid() || !string.Equals(zdo.GetString("hs_store_mode", ""), "price", StringComparison.Ordinal) || zdo.GetBool("hs_store_confirmed", false) || !zdo.GetBool("hs_store_draft_owned_by_chest", false))
			{
				return false;
			}
			string @string = zdo.GetString("hs_store_listing", "");
			string fileName = Path.GetFileName(zdo.GetString("hs_store_blueprint_file", ""));
			bool num = !string.IsNullOrWhiteSpace(requestListingId) && string.Equals(@string, requestListingId, StringComparison.Ordinal);
			bool flag = !string.IsNullOrWhiteSpace(requestBlueprintFile) && string.Equals(fileName, Path.GetFileName(requestBlueprintFile), StringComparison.OrdinalIgnoreCase);
			if (!num && !flag)
			{
				return false;
			}
			name = zdo.GetString("hs_store_blueprint_name", "");
			blueprintFile = fileName;
			return !string.IsNullOrWhiteSpace(blueprintFile);
		}

		[IteratorStateMachine(typeof(<EnumerateModeChests>d__17))]
		private static IEnumerable<ZoneBlueprintStoreChest> EnumerateModeChests(string mode)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <EnumerateModeChests>d__17(-2)
			{
				<>3__mode = mode
			};
		}
	}
	internal readonly struct ZoneBlueprintStoreDraftLease
	{
		public string ListingId { get; }

		public string BlueprintFile { get; }

		public ZoneBlueprintStoreDraftLease(string listingId, string blueprintFile)
		{
			ListingId = listingId;
			BlueprintFile = blueprintFile;
		}
	}
	internal static class ZoneBlueprintStoreDraftRepository
	{
		private const string CatalogFileName = "catalog.yml";

		private const int MaxListingNameLength = 64;

		private static readonly TimeSpan CatalogFlushDelay = TimeSpan.FromSeconds(2.5);

		private static ManualLogSource? _logger;

		private static ZoneBlueprintStoreCatalog? _cachedCatalog;

		private static DateTime _cachedCatalogWriteUtc;

		private static DateTime _nextCatalogFlushUtc;

		private static bool _catalogCacheLoaded;

		private static bool _catalogDirty;

		public static string StoreDirectory => HomesteadPlugin.BlueprintStoreStorageFullPath;

		public static string CatalogPath => Path.Combine(StoreDirectory, "catalog.yml");

		public static void Initialize(ManualLogSource logger)
		{
			_logger = logger;
		}

		public static void Update()
		{
			Flush(force: false);
		}

		public static string TrimName(string name)
		{
			name = (name ?? "").Trim();
			if (name.Length > 64)
			{
				return name.Substring(0, 64);
			}
			return name;
		}

		public static ZoneBlueprintStoreDraftLease CreateDraft(string name, ZoneBlueprintFile blueprint)
		{
			Directory.CreateDirectory(StoreDirectory);
			string text = CreateListingId(name);
			string text2 = text + ".hsbp.yml";
			blueprint.Name = name;
			blueprint.SavedAt = HomesteadTimestamp.Now();
			File.WriteAllText(Path.Combine(StoreDirectory, text2), HomesteadYaml.Serialize(blueprint));
			return new ZoneBlueprintStoreDraftLease(text, text2);
		}

		public static ZoneBlueprintStoreCatalog LoadCatalog()
		{
			return LoadCatalog(clone: true);
		}

		public static ZoneBlueprintStoreCatalog LoadCatalogReadOnly()
		{
			return LoadCatalog(clone: false);
		}

		private static ZoneBlueprintStoreCatalog LoadCatalog(bool clone)
		{
			Directory.CreateDirectory(StoreDirectory);
			if (_catalogDirty && _cachedCatalog != null)
			{
				if (!clone)
				{
					return _cachedCatalog;
				}
				return CloneCatalog(_cachedCatalog);
			}
			if (!File.Exists(CatalogPath))
			{
				ZoneBlueprintStoreCatalog zoneBlueprintStoreCatalog = new ZoneBlueprintStoreCatalog();
				SaveCatalog(zoneBlueprintStoreCatalog, immediate: true);
				ZoneBlueprintStoreCatalog zoneBlueprintStoreCatalog2;
				if (!clone)
				{
					zoneBlueprintStoreCatalog2 = _cachedCatalog;
					if (zoneBlueprintStoreCatalog2 == null)
					{
						return zoneBlueprintStoreCatalog;
					}
				}
				else
				{
					zoneBlueprintStoreCatalog2 = CloneCatalog(zoneBlueprintStoreCatalog);
				}
				return zoneBlueprintStoreCatalog2;
			}
			DateTime lastWriteTimeUtc = File.GetLastWriteTimeUtc(CatalogPath);
			if (_catalogCacheLoaded && _cachedCatalog != null && lastWriteTimeUtc == _cachedCatalogWriteUtc)
			{
				if (!clone)
				{
					return _cachedCatalog;
				}
				return CloneCatalog(_cachedCatalog);
			}
			try
			{
				ZoneBlueprintStoreCatalog zoneBlueprintStoreCatalog3 = HomesteadYaml.Deserialize<ZoneBlueprintStoreCatalog>(File.ReadAllText(CatalogPath));
				NormalizeCatalog(zoneBlueprintStoreCatalog3);
				_cachedCatalog = CloneCatalog(zoneBlueprintStoreCatalog3);
				_cachedCatalogWriteUtc = lastWriteTimeUtc;
				_catalogCacheLoaded = true;
				return clone ? CloneCatalog(zoneBlueprintStoreCatalog3) : _cachedCatalog;
			}
			catch (Exception ex)
			{
				ManualLogSource? logger = _logger;
				if (logger != null)
				{
					logger.LogWarning((object)("Failed to load blueprint store catalog: " + ex.Message));
				}
				return new ZoneBlueprintStoreCatalog();
			}
		}

		public static void SaveCatalog(ZoneBlueprintStoreCatalog catalog, bool immediate = false)
		{
			Directory.CreateDirectory(StoreDirectory);
			NormalizeCatalog(catalog);
			_cachedCatalog = CloneCatalog(catalog);
			_catalogCacheLoaded = true;
			_catalogDirty = true;
			_nextCatalogFlushUtc = DateTime.UtcNow + CatalogFlushDelay;
			if (immediate)
			{
				Flush(force: true);
			}
		}

		public static bool TrySaveCatalogImmediate(ZoneBlueprintStoreCatalog catalog, out string reason)
		{
			SaveCatalog(catalog, immediate: true);
			if (_catalogDirty)
			{
				reason = "Blueprint store catalog could not be saved. Try again shortly.";
				return false;
			}
			reason = "";
			return true;
		}

		public static void Flush(bool force)
		{
			if (!_catalogDirty || _cachedCatalog == null || (!force && DateTime.UtcNow < _nextCatalogFlushUtc))
			{
				return;
			}
			try
			{
				Directory.CreateDirectory(StoreDirectory);
				WriteCatalogAtomic(_cachedCatalog);
				_cachedCatalogWriteUtc = File.GetLastWriteTimeUtc(CatalogPath);
				_catalogDirty = false;
			}
			catch (Exception ex)
			{
				_nextCatalogFlushUtc = DateTime.UtcNow + CatalogFlushDelay;
				ManualLogSource? logger = _logger;
				if (logger != null)
				{
					logger.LogWarning((object)("Failed to flush blueprint store catalog: " + ex.Message));
				}
			}
		}

		private static void WriteCatalogAtomic(ZoneBlueprintStoreCatalog catalog)
		{
			string text = CatalogPath + ".tmp";
			File.WriteAllText(text, HomesteadYaml.Serialize(catalog));
			if (!File.Exists(CatalogPath))
			{
				File.Move(text, CatalogPath);
				return;
			}
			try
			{
				File.Replace(text, CatalogPath, null);
			}
			catch
			{
				File.Copy(text, CatalogPath, overwrite: true);
				File.Delete(text);
			}
		}

		private static void NormalizeCatalog(ZoneBlueprintStoreCatalog catalog)
		{
			ZoneBlueprintStoreCatalog zoneBlueprintStoreCatalog = catalog;
			if (zoneBlueprintStoreCatalog.Listings == null)
			{
				List<ZoneBlueprintStoreListing> list2 = (zoneBlueprintStoreCatalog.Listings = new List<ZoneBlueprintStoreListing>());
			}
			zoneBlueprintStoreCatalog = catalog;
			if (zoneBlueprintStoreCatalog.Offers == null)
			{
				List<ZoneBlueprintStoreOffer> list4 = (zoneBlueprintStoreCatalog.Offers = new List<ZoneBlueprintStoreOffer>());
			}
			zoneBlueprintStoreCatalog = catalog;
			if (zoneBlueprintStoreCatalog.Notifications == null)
			{
				List<ZoneBlueprintStoreNotification> list6 = (zoneBlueprintStoreCatalog.Notifications = new List<ZoneBlueprintStoreNotification>());
			}
			zoneBlueprintStoreCatalog = catalog;
			if (zoneBlueprintStoreCatalog.Balances == null)
			{
				List<ZoneBlueprintStoreBalance> list8 = (zoneBlueprintStoreCatalog.Balances = new List<ZoneBlueprintStoreBalance>());
			}
		}

		private static ZoneBlueprintStoreCatalog CloneCatalog(ZoneBlueprintStoreCatalog source)
		{
			NormalizeCatalog(source);
			return new ZoneBlueprintStoreCatalog
			{
				Version = source.Version,
				Listings = source.Listings.Select(CloneListing).ToList(),
				Offers = source.Offers.Select(CloneOffer).ToList(),
				Notifications = source.Notifications.Select(CloneNotification).ToList(),
				Balances = source.Balances.Select(CloneBalance).ToList()
			};
		}

		private static ZoneBlueprintStoreListing CloneListing(ZoneBlueprintStoreListing source)
		{
			return new ZoneBlueprintStoreListing
			{
				ListingId = source.ListingId,
				Name = source.Name,
				SellerName = source.SellerName,
				SellerPlayerId = source.SellerPlayerId,
				SellerPlatformId = source.SellerPlatformId,
				CreatedAt = source.CreatedAt,
				ExpiresAt = source.ExpiresAt,
				PriceItems = ClonePriceItems(source.PriceItems),
				EntryCount = source.EntryCount,
				PurchaseCount = source.PurchaseCount,
				BlueprintFile = source.BlueprintFile,
				IconPngBase64 = source.IconPngBase64,
				Active = source.Active
			};
		}

		private static ZoneBlueprintStoreOffer CloneOffer(ZoneBlueprintStoreOffer source)
		{
			return new ZoneBlueprintStoreOffer
			{
				OfferId = source.OfferId,
				ListingId = source.ListingId,
				BuyerName = source.BuyerName,
				BuyerPlayerId = source.BuyerPlayerId,
				BuyerPlatformId = source.BuyerPlatformId,
				CreatedAt = source.CreatedAt,
				UpdatedAt = source.UpdatedAt,
				Status = source.Status,
				PriceItems = ClonePriceItems(source.PriceItems)
			};
		}

		private static ZoneBlueprintStoreNotification CloneNotification(ZoneBlueprintStoreNotification source)
		{
			return new ZoneBlueprintStoreNotification
			{
				NotificationId = source.NotificationId,
				Type = source.Type,
				RecipientPlatformId = source.RecipientPlatformId,
				RecipientPlayerId = source.RecipientPlayerId,
				RecipientName = source.RecipientName,
				ActorName = source.ActorName,
				ListingId = source.ListingId,
				ListingName = source.ListingName,
				OfferId = source.OfferId,
				Message = source.Message,
				CreatedAt = source.CreatedAt,
				Read = source.Read,
				ReadByPlatformIds = (source.ReadByPlatformIds?.ToList() ?? new List<string>()),
				ReadByPlayerIds = (source.ReadByPlayerIds?.ToList() ?? new List<long>())
			};
		}

		private static ZoneBlueprintStoreBalance CloneBalance(ZoneBlueprintStoreBalance source)
		{
			return new ZoneBlueprintStoreBalance
			{
				SellerPlayerId = source.SellerPlayerId,
				SellerPlatformId = source.SellerPlatformId,
				SellerName = source.SellerName,
				Coins = source.Coins,
				Materials = ClonePriceItems(source.Materials)
			};
		}

		private static List<ZoneBlueprintStorePriceItem> ClonePriceItems(IEnumerable<ZoneBlueprintStorePriceItem>? source)
		{
			return source?.Select((ZoneBlueprintStorePriceItem item) => new ZoneBlueprintStorePriceItem
			{
				ItemName = item.ItemName,
				PrefabName = item.PrefabName,
				DisplayName = item.DisplayName,
				Amount = item.Amount
			}).ToList() ?? new List<ZoneBlueprintStorePriceItem>();
		}

		public static bool DeactivateExpiredListings(ZoneBlueprintStoreCatalog catalog)
		{
			DateTime utcNow = DateTime.UtcNow;
			bool flag = false;
			foreach (ZoneBlueprintStoreListing listing in catalog.Listings)
			{
				if (listing.Active && !string.IsNullOrWhiteSpace(listing.ExpiresAt) && listing.PurchaseCount <= BlueprintConfig.StoreSettings.AutoDelistMaxPurchases && HomesteadTimestamp.IsExpired(listing.ExpiresAt, utcNow))
				{
					listing.Active = false;
					flag = true;
				}
			}
			if (flag)
			{
				SaveCatalog(catalog);
			}
			return flag;
		}

		public static bool TryLoadBlueprintFile(string blueprintFile, out ZoneBlueprintFile blueprint, out string reason)
		{
			blueprint = null;
			reason = "";
			string fileName = Path.GetFileName(blueprintFile ?? "");
			if (string.IsNullOrWhiteSpace(fileName))
			{
				reason = "Blueprint store file is missing.";
				return false;
			}
			string path = Path.Combine(StoreDirectory, fileName);
			if (!File.Exists(path))
			{
				reason = "Blueprint store file is missing.";
				return false;
			}
			try
			{
				blueprint = HomesteadYaml.Deserialize<ZoneBlueprintFile>(File.ReadAllText(path));
				return true;
			}
			catch (Exception ex)
			{
				reason = "Failed to load blueprint store file: " + ex.Message;
				return false;
			}
		}

		public static bool TryGetBlueprintFileWriteUtc(string blueprintFile, out DateTime writeUtc)
		{
			writeUtc = default(DateTime);
			string fileName = Path.GetFileName(blueprintFile ?? "");
			if (string.IsNullOrWhiteSpace(fileName))
			{
				return false;
			}
			string path = Path.Combine(StoreDirectory, fileName);
			if (!File.Exists(path))
			{
				return false;
			}
			writeUtc = File.GetLastWriteTimeUtc(path);
			return true;
		}

		public static void DeleteFile(string blueprintFile)
		{
			if (string.IsNullOrWhiteSpace(blueprintFile))
			{
				return;
			}
			try
			{
				string fileName = Path.GetFileName(blueprintFile);
				string path = Path.Combine(StoreDirectory, fileName);
				if (File.Exists(path))
				{
					File.Delete(path);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource? logger = _logger;
				if (logger != null)
				{
					logger.LogWarning((object)("Failed to delete blueprint store draft '" + blueprintFile + "': " + ex.Message));
				}
			}
		}

		public static bool HasOrphanDraftCandidates(TimeSpan grace)
		{
			try
			{
				if (!Directory.Exists(StoreDirectory))
				{
					return false;
				}
				HashSet<string> hashSet = (from listing in LoadCatalog().Listings
					select Path.GetFileName(listing.BlueprintFile ?? "") into file
					where !string.IsNullOrWhiteSpace(file)
					select file).ToHashSet<string>(StringComparer.OrdinalIgnoreCase);
				DateTime dateTime = DateTime.UtcNow - grace;
				string[] files = Directory.GetFiles(StoreDirectory, "*.hsbp.yml", SearchOption.TopDirectoryOnly);
				foreach (string path in files)
				{
					string fileName = Path.GetFileName(path);
					if (!hashSet.Contains(fileName) && File.GetLastWriteTimeUtc(path) <= dateTime)
					{
						return true;
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource? logger = _logger;
				if (logger != null)
				{
					logger.LogWarning((object)("Blueprint store orphan draft precheck failed: " + ex.Message));
				}
			}
			return false;
		}

		public static void SweepOrphanDrafts(HashSet<string> liveDraftFiles, TimeSpan grace)
		{
			try
			{
				if (!Directory.Exists(StoreDirectory))
				{
					return;
				}
				HashSet<string> hashSet = (from listing in LoadCatalog().Listings
					select Path.GetFileName(listing.BlueprintFile ?? "") into file
					where !string.IsNullOrWhiteSpace(file)
					select file).ToHashSet<string>(StringComparer.OrdinalIgnoreCase);
				DateTime dateTime = DateTime.UtcNow - grace;
				int num = 0;
				string[] files = Directory.GetFiles(StoreDirectory, "*.hsbp.yml", SearchOption.TopDirectoryOnly);
				foreach (string path in files)
				{
					string fileName = Path.GetFileName(path);
					if (!hashSet.Contains(fileName) && !liveDraftFiles.Contains(fileName) && !(File.GetLastWriteTimeUtc(path) > dateTime))
					{
						File.Delete(path);
						num++;
					}
				}
				if (num > 0)
				{
					ManualLogSource? logger = _logger;
					if (logger != null)
					{
						logger.LogInfo((object)$"Blueprint store orphan draft sweep deleted {num} file(s).");
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource? logger2 = _logger;
				if (logger2 != null)
				{
					logger2.LogWarning((object)("Blueprint store orphan draft sweep failed: " + ex.Message));
				}
			}
		}

		private static string CreateListingId(string name)
		{
			string text = new string(name.Select((char ch) => (!char.IsLetterOrDigit(ch)) ? '_' : ch).ToArray());
			text = (string.IsNullOrWhiteSpace(text) ? "blueprint" : text.Trim(new char[1] { '_' }));
			string text2 = $"{DateTime.UtcNow:yyyyMMddHHmmss}_{text}_{Guid.NewGuid():N}".ToLowerInvariant();
			if (text2.Length > 64)
			{
				return text2.Substring(0, 64);
			}
			return text2;
		}
	}
	internal static class ZoneBlueprintStoreIdentity
	{
		public static ZoneBlueprintStoreActor Actor(long playerId, string platformId)
		{
			return new ZoneBlueprintStoreActor(playerId, platformId);
		}

		public static bool Matches(long storedPlayerId, string storedPlatformId, long playerId, string platformId, BlueprintStoreIdentityMode mode)
		{
			if (playerId == 0L)
			{
				return false;
			}
			if (mode == BlueprintStoreIdentityMode.PlayerId)
			{
				return storedPlayerId == playerId;
			}
			string text = HomesteadPlayerIdentity.NormalizePlatformId(storedPlatformId);
			string text2 = HomesteadPlayerIdentity.NormalizePlatformId(platformId);
			if (!string.IsNullOrWhiteSpace(text) && !string.IsNullOrWhiteSpace(text2) && string.Equals(text, text2, StringComparison.Ordinal))
			{
				return true;
			}
			if (string.IsNullOrWhiteSpace(text))
			{
				return storedPlayerId == playerId;
			}
			return false;
		}

		public static string HiddenStateKey(long playerId, string platformId, BlueprintStoreIdentityMode mode)
		{
			if (mode == BlueprintStoreIdentityMode.PlayerId)
			{
				if (playerId == 0L)
				{
					return HomesteadPlayerIdentity.NormalizePlatformId(platformId);
				}
				return "player:" + playerId;
			}
			platformId = HomesteadPlayerIdentity.NormalizePlatformId(platformId);
			if (string.IsNullOrWhiteSpace(platformId))
			{
				if (playerId == 0L)
				{
					return "";
				}
				return "player:" + playerId;
			}
			return platformId;
		}

		public static string HiddenStateKey(ZoneBlueprintStoreActor actor, BlueprintStoreIdentityMode mode)
		{
			return HiddenStateKey(actor.PlayerId, actor.PlatformId, mode);
		}
	}
	internal readonly struct ZoneBlueprintStoreActor
	{
		public long PlayerId { get; }

		public string PlatformId { get; }

		public bool IsValid => PlayerId != 0;

		public ZoneBlueprintStoreActor(long playerId, string platformId)
		{
			PlayerId = playerId;
			PlatformId = HomesteadPlayerIdentity.NormalizePlatformId(platformId);
		}

		public bool MatchesStored(long storedPlayerId, string storedPlatformId, BlueprintStoreIdentityMode mode)
		{
			return ZoneBlueprintStoreIdentity.Matches(storedPlayerId, storedPlatformId, PlayerId, PlatformId, mode);
		}

		public string Key(BlueprintStoreIdentityMode mode)
		{
			return ZoneBlueprintStoreIdentity.HiddenStateKey(this, mode);
		}
	}
	internal static class ZoneBlueprintStoreNotificationsUi
	{
		private const int MaxRows = 8;

		private const float ScrollWheelThreshold = 0.05f;

		private const float ButtonWidth = 42f;

		private const float ButtonHeight = 38f;

		private const float PanelWidth = 540f;

		private const float PanelHeight = 430f;

		private static readonly Vector2 ButtonPanelInset = new Vector2(-18f, -18f);

		private static GameObject? _buttonRoot;

		private static Text? _badgeText;

		private static GameObject? _panel;

		private static Text? _statusText;

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

		private static readonly List<Text> RowTexts = new List<Text>();

		private static readonly List<ZoneBlueprintStoreNotificationDto> Notifications = new List<ZoneBlueprintStoreNotificationDto>();

		private static int _scrollOffset;

		private static bool _buttonPointerDown;

		private static bool _buttonDragging;

		private static bool _buttonDragMoved;

		private static Vector2 _buttonDragStartMouse;

		private static Vector2 _buttonDragStartOffset;

		private static Vector2? _runtimeButtonOffset;

		private static bool _panelPointerDown;

		private static bool _panelDragging;

		private static bool _panelDragMoved;

		private static Vector2 _panelDragStartMouse;

		private static Vector2 _panelDragStartOffset;

		private static bool _inputBlocked;

		public static void SetNotifications(IEnumerable<ZoneBlueprintStoreNotificationDto> notifications)
		{
			Merge(notifications);
			Refresh();
		}

		public static void AddNotifications(IEnumerable<ZoneBlueprintStoreNotificationDto> notifications)
		{
			bool num = Merge(notifications);
			Refresh();
			if (num && BlueprintConfig.StoreNotificationAutoOpen)
			{
				OpenPanel(markAsRead: false);
			}
		}

		public static void Update()
		{
			if (!IsInWorld())
			{
				HideForWorldExit();
				return;
			}
			if (!BlueprintConfig.StoreNotificationButtonEnabled)
			{
				if ((Object)(object)_buttonRoot != (Object)null && Object.op_Implicit((Object)(object)_buttonRoot))
				{
					_buttonRoot.SetActive(false);
				}
				ResetButtonPointerState();
				if (_inputBlocked && !IsPanelVisible())
				{
					SetInputBlocked(blocked: false);
				}
			}
			else
			{
				EnsureButton();
				UpdateButtonParent();
				HandleButtonPointer();
				HandlePanelPointer();
				RefreshButtonVisibility();
			}
			if (_inputBlocked && !IsPanelVisible())
			{
				SetInputBlocked(blocked: false);
			}
			if (IsPanelVisible() && Input.GetKeyDown((KeyCode)27))
			{
				ClosePanel();
			}
			else if (IsPanelVisible())
			{
				UpdateButtonParent();
				HandleScrollInput();
			}
		}

		private static bool IsInWorld()
		{
			if ((Object)(object)Player.m_localPlayer != (Object)null)
			{
				return (Object)(object)ZNet.instance != (Object)null;
			}
			return false;
		}

		private static void HideForWorldExit()
		{
			if ((Object)(object)_panel != (Object)null && Object.op_Implicit((Object)(object)_panel))
			{
				_panel.SetActive(false);
			}
			if ((Object)(object)_buttonRoot != (Object)null && Object.op_Implicit((Object)(object)_buttonRoot))
			{
				_buttonRoot.SetActive(false);
			}
			ResetButtonPointerState();
			ResetPanelPointerState();
			if (_inputBlocked)
			{
				SetInputBlocked(blocked: false);
			}
		}

		private static bool Merge(IEnumerable<ZoneBlueprintStoreNotificationDto>? notifications)
		{
			if (notifications == null)
			{
				return false;
			}
			bool result = false;
			foreach (ZoneBlueprintStoreNotificationDto notification in notifications)
			{
				if (string.IsNullOrWhiteSpace(notification.NotificationId) || !ShouldDisplayNotification(notification))
				{
					continue;
				}
				int num = Notifications.FindIndex((ZoneBlueprintStoreNotificationDto item) => string.Equals(item.NotificationId, notification.NotificationId, StringComparison.Ordinal));
				if (num >= 0)
				{
					Notifications[num] = notification;
					continue;
				}
				Notifications.Add(notification);
				if (!notification.Read)
				{
					result = true;
				}
			}
			Notifications.Sort((ZoneBlueprintStoreNotificationDto left, ZoneBlueprintStoreNotificationDto right) => string.Compare(right.CreatedAt, left.CreatedAt, StringComparison.Ordinal));
			if (Notifications.Count > 64)
			{
				Notifications.RemoveRange(64, Notifications.Count - 64);
			}
			return result;
		}

		private static void EnsureButton()
		{
			//IL_0048: 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_0066: 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_00ac: Expected O, but got Unknown
			//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_00d8: 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_00ed: 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_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: 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_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			if ((!((Object)(object)_buttonRoot != (Object)null) || !Object.op_Implicit((Object)(object)_buttonRoot)) && !((Object)(object)GUIManager.CustomGUIFront == (Object)null))
			{
				GUIManager instance = GUIManager.Instance;
				_buttonRoot = instance.CreateButton("!", GUIManager.CustomGUIFront.transform, new Vector2(1f, 1f), new Vector2(1f, 1f), new Vector2(-62f, -118f), 42f, 38f);
				((Object)_buttonRoot).name = "HomesteadStoreNotificationButton";
				GameObject val = new GameObject("Badge", new Type[1] { typeof(RectTransform) });
				val.transform.SetParent(_buttonRoot.transform, false);
				RectTransform val2 = (RectTransform)val.transform;
				val2.anchorMin = new Vector2(0.5f, 1f);
				val2.anchorMax = new Vector2(0.5f, 1f);
				val2.pivot = new Vector2(0.5f, 0.5f);
				val2.anchoredPosition = new Vector2(0f, 10f);
				val2.sizeDelta = new Vector2(64f, 34f);
				_badgeText = instance.CreateText("", val.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), Vector2.zero, instance.AveriaSerifBold, 26, instance.ValheimYellow, true, Color.black, 64f, 34f, false).GetComponent<Text>();
				_badgeText.alignment = (TextAnchor)4;
				UpdateButtonParent();
				RefreshButtonVisibility();
			}
		}

		private static void UpdateButtonParent()
		{
			//IL_00a1: 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_00cb: 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_010c: 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_00e8: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_buttonRoot == (Object)null || !Object.op_Implicit((Object)(object)_buttonRoot))
			{
				return;
			}
			bool flag = IsPanelVisible();
			object obj;
			if (!flag || !((Object)(object)_panel != (Object)null) || !Object.op_Implicit((Object)(object)_panel))
			{
				GameObject customGUIFront = GUIManager.CustomGUIFront;
				obj = ((customGUIFront != null) ? customGUIFront.transform : null);
			}
			else
			{
				obj = _panel.transform;
			}
			Transform val = (Transform)obj;
			if (!((Object)(object)val == (Object)null))
			{
				if ((Object)(object)_buttonRoot.transform.parent != (Object)(object)val)
				{
					_buttonRoot.transform.SetParent(val, false);
				}
				RectTransform component = _buttonRoot.GetComponent<RectTransform>();
				component.anchorMin = new Vector2(1f, 1f);
				component.anchorMax = new Vector2(1f, 1f);
				component.pivot = new Vector2(1f, 1f);
				component.anchoredPosition = (Vector2)(flag ? ButtonPanelInset : (((??)_runtimeButtonOffset) ?? BlueprintConfig.StoreNotificationButtonOffset));
				component.sizeDelta = new Vector2(42f, 38f);
			}
		}

		private static void PositionPanelAtButton()
		{
			//IL_003a: 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_0064: 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_0084: 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)
			if (!((Object)(object)_panel == (Object)null) && Object.op_Implicit((Object)(object)_panel))
			{
				RectTransform component = _panel.GetComponent<RectTransform>();
				if (!((Object)(object)component == (Object)null))
				{
					component.anchorMin = new Vector2(1f, 1f);
					component.anchorMax = new Vector2(1f, 1f);
					component.pivot = new Vector2(1f, 1f);
					component.sizeDelta = new Vector2(540f, 430f);
					component.anchoredPosition = PanelOffsetFromButtonOffset(CurrentButtonOffset());
				}
			}
		}

		private static Vector2 CurrentButtonOffset()
		{
			//IL_00ae: 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_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)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			if (IsPanelVisible() && (Object)(object)_panel != (Object)null && Object.op_Implicit((Object)(object)_panel))
			{
				RectTransform component = _panel.GetComponent<RectTransform>();
				if ((Object)(object)component != (Object)null)
				{
					return ButtonOffsetFromPanelOffset(component.anchoredPosition);
				}
			}
			if ((Object)(object)_buttonRoot != (Object)null && Object.op_Implicit((Object)(object)_buttonRoot))
			{
				RectTransform component2 = _buttonRoot.GetComponent<RectTransform>();
				if ((Object)(object)component2 != (Object)null)
				{
					Transform parent = ((Component)component2).transform.parent;
					GameObject customGUIFront = GUIManager.CustomGUIFront;
					if ((Object)(object)parent == (Object)(object)((customGUIFront != null) ? customGUIFront.transform : null))
					{
						return component2.anchoredPosition;
					}
				}
			}
			return (Vector2)(((??)_runtimeButtonOffset) ?? BlueprintConfig.StoreNotificationButtonOffset);
		}

		private static void SetCurrentButtonOffset(Vector2 offset)
		{
			//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_0006: 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_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: 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)
			offset = ClampNotificationButtonOffset(offset);
			_runtimeButtonOffset = offset;
			if (IsPanelVisible() && (Object)(object)_panel != (Object)null && Object.op_Implicit((Object)(object)_panel))
			{
				RectTransform component = _panel.GetComponent<RectTransform>();
				if ((Object)(object)component != (Object)null)
				{
					component.anchoredPosition = PanelOffsetFromButtonOffset(offset);
				}
			}
			else if ((Object)(object)_buttonRoot != (Object)null && Object.op_Implicit((Object)(object)_buttonRoot))
			{
				RectTransform component2 = _buttonRoot.GetComponent<RectTransform>();
				if ((Object)(object)component2 != (Object)null)
				{
					component2.anchoredPosition = offset;
				}
			}
		}

		private static void HandleButtonPointer()
		{
			//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)
			//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_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_007d: 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_00a2: 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)
			//IL_00b1: 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_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_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_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_buttonRoot == (Object)null || !Object.op_Implicit((Object)(object)_buttonRoot) || !_buttonRoot.activeInHierarchy)
			{
				ResetButtonPointerState();
				return;
			}
			RectTransform component = _buttonRoot.GetComponent<RectTransform>();
			bool flag = RectTransformUtility.RectangleContainsScreenPoint(component, Vector2.op_Implicit(Input.mousePosition));
			if (Input.GetMouseButtonDown(0) && flag)
			{
				_buttonPointerDown = true;
				_buttonDragging = true;
				_buttonDragMoved = false;
				_buttonDragStartMouse = Vector2.op_Implicit(Input.mousePosition);
				_buttonDragStartOffset = CurrentButtonOffset();
				_runtimeButtonOffset = _buttonDragStartOffset;
			}
			if (_buttonPointerDown && _buttonDragging && Input.GetMouseButton(0))
			{
				Vector2 val = Vector2.op_Implicit(Input.mousePosition) - _buttonDragStartMouse;
				if (((Vector2)(ref val)).sqrMagnitude > 16f)
				{
					_buttonDragMoved = true;
				}
				SetCurrentButtonOffset(ClampNotificationButtonOffset(_buttonDragStartOffset + val));
			}
			if (_buttonPointerDown && Input.GetMouseButtonUp(0))
			{
				flag = RectTransformUtility.RectangleContainsScreenPoint(component, Vector2.op_Implicit(Input.mousePosition));
				if (_buttonDragging && _buttonDragMoved)
				{
					Vector2 val2 = ClampNotificationButtonOffset(CurrentButtonOffset());
					SetCurrentButtonOffset(val2);
					BlueprintConfig.SetStoreNotificationButtonOffset(val2);
				}
				else if (flag)
				{
					TogglePanel();
				}
				ResetButtonPointerState(_buttonDragging && _buttonDragMoved);
			}
		}

		private static void HandlePanelPointer()
		{
			//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_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_008a: 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_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: 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_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			if (!IsPanelVisible() || (Object)(object)_panel == (Object)null || !Object.op_Implicit((Object)(object)_panel))
			{
				ResetPanelPointerState();
				return;
			}
			RectTransform component = _panel.GetComponent<RectTransform>();
			if ((Object)(object)component == (Object)null)
			{
				ResetPanelPointerState();
				return;
			}
			bool flag = RectTransformUtility.RectangleContainsScreenPoint(component, Vector2.op_Implicit(Input.mousePosition));
			bool flag2 = IsPointerOverButton();
			if (Input.GetMouseButtonDown(0) && flag && !flag2)
			{
				_panelPointerDown = true;
				_panelDragging = true;
				_panelDragMoved = false;
				_panelDragStartMouse = Vector2.op_Implicit(Input.mousePosition);
				_panelDragStartOffset = CurrentButtonOffset();
			}
			if (_panelPointerDown && _panelDragging && Input.GetMouseButton(0))
			{
				Vector2 val = Vector2.op_Implicit(Input.mousePosition) - _panelDragStartMouse;
				if (((Vector2)(ref val)).sqrMagnitude > 16f)
				{
					_panelDragMoved = true;
				}
				SetCurrentButtonOffset(_panelDragStartOffset + val);
			}
			if (_panelPointerDown && Input.GetMouseButtonUp(0))
			{
				if (_panelDragging && _panelDragMoved)
				{
					Vector2 val2 = ClampNotificationButtonOffset(CurrentButtonOffset());
					SetCurrentButtonOffset(val2);
					_runtimeButtonOffset = val2;
					BlueprintConfig.SetStoreNotificationButtonOffset(val2);
				}
				ResetPanelPointerState();
			}
		}

		private static bool IsPointerOverButton()
		{
			//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)
			if ((Object)(object)_buttonRoot == (Object)null || !Object.op_Implicit((Object)(object)_buttonRoot) || !_buttonRoot.activeInHierarchy)
			{
				return false;
			}
			RectTransform component = _buttonRoot.GetComponent<RectTransform>();
			if ((Object)(object)component != (Object)null)
			{
				return RectTransformUtility.RectangleContainsScreenPoint(component, Vector2.op_Implicit(Input.mousePosition));
			}
			return false;
		}

		private static void ResetButtonPointerState(bool keepRuntimeOffset = false)
		{
			_buttonPointerDown = false;
			_buttonDragging = false;
			_buttonDragMoved = false;
			if (!keepRuntimeOffset)
			{
				_runtimeButtonOffset = null;
			}
		}

		private static void ResetPanelPointerState()
		{
			_panelPointerDown = false;
			_panelDragging = false;
			_panelDragMoved = false;
		}

		private static Vector2 ClampNotificationButtonOffset(Vector2 offset)
		{
			//IL_0002: 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_0038: Unknown result type (might be due to invalid IL or missing references)
			offset.x = Mathf.Clamp(offset.x, -3000f, 3000f);
			offset.y = Mathf.Clamp(offset.y, -3000f, 3000f);
			return offset;
		}

		private static Vector2 PanelOffsetFromButtonOffset(Vector2 buttonOffset)
		{
			//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_0006: Unknown result type (might be due to invalid IL or missing references)
			return buttonOffset - ButtonPanelInset;
		}

		private static Vector2 ButtonOffsetFromPanelOffset(Vector2 panelOffset)
		{
			//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_0006: Unknown result type (might be due to invalid IL or missing references)
			return panelOffset + ButtonPanelInset;
		}

		private static void TogglePanel()
		{
			if (IsPanelVisible())
			{
				ClosePanel();
			}
			else
			{
				OpenPanel(markAsRead: true);
			}
		}

		private static void EnsurePanel()
		{
			//IL_0064: 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_0082: 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_00db: 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_00f8: 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_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Expected O, but got Unknown
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: 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_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_0303: Unknown result type (might be due to invalid IL or missing references)
			//IL_0312: Unknown result type (might be due to invalid IL or missing references)
			//IL_0321: Unknown result type (might be due to invalid IL or missing references)
			//IL_032f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0335: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: 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_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: 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_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_0270: 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_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			if ((!((Object)(object)_panel != (Object)null) || !Object.op_Implicit((Object)(object)_panel) || Rows.Count != 8) && !((Object)(object)GUIManager.CustomGUIFront == (Object)null))
			{
				Rows.Clear();
				RowTexts.Clear();
				GUIManager instance = GUIManager.Instance;
				_panel = instance.CreateWoodpanel(GUIManager.CustomGUIFront.transform, new Vector2(1f, 1f), new Vector2(1f, 1f), new Vector2(-300f, -340f), 540f, 430f, false);
				((Object)_panel).name = "HomesteadStoreNotificationPanel";
				Transform transform = _panel.transform;
				instance.CreateText(HomesteadLocalization.Text("hs_store_notifications_title"), transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -28f), instance.AveriaSerifBold, 20, instance.ValheimOrange, true, Color.black, 460f, 28f, false);
				for (int i = 0; i < 8; i++)
				{
					GameObject val = new GameObject($"NotificationRow{i}");
					val.transform.SetParent(transform, false);
					RectTransform obj = val.AddComponent<RectTransform>();
					obj.anchorMin = new Vector2(0.5f, 1f);
					obj.anchorMax = new Vector2(0.5f, 1f);
					obj.pivot = new Vector2(0.5f, 1f);
					obj.anchoredPosition = new Vector2(0f, -66f - (float)i * 38f);
					obj.sizeDelta = new Vector2(480f, 34f);
					((Graphic)val.AddComponent<Image>()).color = ((i % 2 == 0) ? new Color(0.05f, 0.045f, 0.035f, 0.32f) : new Color(0.02f, 0.018f, 0.014f, 0.22f));
					Text component = instance.CreateText("", val.transform, new Vector2(0f, 0.5f), new Vector2(0f, 0.5f), new Vector2(10f, 0f), instance.AveriaSerif, 13, instance.ValheimBeige, true, Color.black, 456f, 30f, false).GetComponent<Text>();
					RectTransform component2 = ((Component)component).GetComponent<RectTransform>();
					component2.anchorMin = Vector2.zero;
					component2.anchorMax = Vector2.one;
					component2.pivot = new Vector2(0f, 0.5f);
					component2.offsetMin = new Vector2(12f, 2f);
					component2.offsetMax = new Vector2(-12f, -2f);
					component.alignment = (TextAnchor)3;
					component.horizontalOverflow = (HorizontalWrapMode)0;
					component.verticalOverflow = (VerticalWrapMode)0;
					Rows.Add(val);
					RowTexts.Add(component);
				}
				_statusText = instance.CreateText("", transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -378f), instance.AveriaSerif, 13, instance.ValheimYellow, true, Color.black, 460f, 24f, false).GetComponent<Text>();
				RefreshPanel();
				_panel.SetActive(false);
			}
		}

		private static void OpenPanel(bool markAsRead)
		{
			EnsurePanel();
			if (!((Object)(object)_panel == (Object)null) && Object.op_Implicit((Object)(object)_panel))
			{
				PositionPanelAtButton();
				_panel.SetActive(true);
				UpdateButtonParent();
				_scrollOffset = 0;
				if (markAsRead)
				{
					MarkUnreadAsRead();
				}
				RefreshPanel();
			}
		}

		private static void MarkUnreadAsRead()
		{
			PruneHiddenNotifications();
			List<string> list = (from notification in Notifications
				where !notification.Read
				select notification.NotificationId).ToList();
			if (list.Count == 0)
			{
				return;
			}
			foreach (ZoneBlueprintStoreNotificationDto notification in Notifications)
			{
				if (list.Contains(notification.NotificationId))
				{
					notification.Read = true;
				}
			}
			ZoneBlueprintStore.RequestReadNotifications(list);
			RefreshButtonVisibility();
		}

		private static void Refresh()
		{
			PruneHiddenNotifications();
			RefreshButtonVisibility();
			if (IsPanelVisible())
			{
				RefreshPanel();
			}
		}

		private static void RefreshButtonVisibility()
		{
			PruneHiddenNotifications();
			if (!BlueprintConfig.StoreNotificationButtonEnabled)
			{
				if ((Object)(object)_buttonRoot != (Object)null && Object.op_Implicit((Object)(object)_buttonRoot))
				{
					_buttonRoot.SetActive(false);
				}
				return;
			}
			EnsureButton();
			int num = Notifications.Count((ZoneBlueprintStoreNotificationDto notification) => !notification.Read);
			if ((Object)(object)_buttonRoot != (Object)null && Object.op_Implicit((Object)(object)_buttonRoot))
			{
				_buttonRoot.SetActive(true);
			}
			if ((Object)(object)_badgeText != (Object)null && Object.op_Implicit((Object)(object)_badgeText))
			{
				_badgeText.text = ((num > 99) ? "99+" : num.ToString());
				((Component)((Component)_badgeText).transform.parent).gameObject.SetActive(num > 0);
			}
		}

		private static void RefreshPanel()
		{
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			PruneHiddenNotifications();
			_scrollOffset = Mathf.Clamp(_scrollOffset, 0, Mathf.Max(0, Notifications.Count - 8));
			for (int i = 0; i < Rows.Count; i++)
			{
				int num = _scrollOffset + i;
				bool flag = num < Notifications.Count;
				Rows[i].SetActive(flag);
				if (flag)
				{
					ZoneBlueprintStoreNotificationDto zoneBlueprintStoreNotificationDto = Notifications[num];
					RowTexts[i].text = zoneBlueprintStoreNotificationDto.Message;
					((Graphic)RowTexts[i]).color = (zoneBlueprintStoreNotificationDto.Read ? GUIManager.Instance.ValheimBeige : GUIManager.Instance.ValheimYellow);
				}
			}
			if ((Object)(object)_statusText != (Object)null && Object.op_Implicit((Object)(object)_statusText))
			{
				int num2 = Notifications.Count((ZoneBlueprintStoreNotificationDto notification) => !notification.Read);
				if (Notifications.Count == 0)
				{
					_statusText.text = HomesteadLocalization.Text("hs_store_no_notifications");
					return;
				}
				int num3 = _scrollOffset + 1;
				int num4 = Mathf.Min(_scrollOffset + 8, Notifications.Count);
				_statusText.text = HomesteadLocalization.Format("hs_store_notifications_status", num3, num4, Notifications.Count, num2);
			}
		}

		private static void HandleScrollInput()
		{
			if (Notifications.Count <= 8)
			{
				return;
			}
			float axis = Input.GetAxis("Mouse ScrollWheel");
			if (!(Mathf.Abs(axis) < 0.05f))
			{
				int num = ((axis < 0f) ? 1 : (-1));
				int num2 = Mathf.Clamp(_scrollOffset + num, 0, Mathf.Max(0, Notifications.Count - 8));
				if (num2 != _scrollOffset)
				{
					_scrollOffset = num2;
					RefreshPanel();
				}
			}
		}

		private static void ClosePanel()
		{
			if ((Object)(object)_panel != (Object)null && Object.op_Implicit((Object)(object)_panel))
			{
				_panel.SetActive(false);
			}
			UpdateButtonParent();
			RefreshButtonVisibility();
		}

		private static bool IsPanelVisible()
		{
			if ((Object)(object)_panel != (Object)null && Object.op_Implicit((Object)(object)_panel))
			{
				return _panel.activeInHierarchy;
			}
			return false;
		}

		private static void SetInputBlocked(bool blocked)
		{
			if (_inputBlocked != blocked)
			{
				GUIManager.BlockInput(blocked);
				_inputBlocked = blocked;
			}
		}

		private static void PruneHiddenNotifications()
		{
			Notifications.RemoveAll((ZoneBlueprintStoreNotificationDto notification) => !ShouldDisplayNotification(notification));
		}

		private static bool ShouldDisplayNotification(ZoneBlueprintStoreNotificationDto notification)
		{
			return BlueprintConfig.StoreNotificationsEnabled;
		}
	}
	internal static class ZoneBlueprintStoreOffersUi
	{
		private sealed class OfferRowWidgets
		{
			public Text Buyer;

			public Text Price;

			public Text Status;

			public Button BuyButton;

			public Button AcceptButton;

			public Button DeclineButton;

			public Button DeleteButton;

			public readonly List<Image> PriceIcons = new List<Image>();

			public readonly List<Text> PriceAmounts = new List<Text>();
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction <0>__BackToStore;

			public static UnityAction <1>__RefreshCurrent;

			public static UnityAction <2>__Close;
		}

		private const int MaxRows = 6;

		private const int PriceSlots = 8;

		private static GameObject? _panel;

		private static Text? _titleText;

		private static Text? _statusText;

		private static Text? _backButtonText;

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

		private static readonly List<OfferRowWidgets> RowWidgets = new List<OfferRowWidgets>();

		private static List<ZoneBlueprintStoreOfferDto> _offers = new List<ZoneBlueprintStoreOfferDto>();

		private static string _listingId = "";

		private static string _listingName = "";

		private static int _scrollOffset;

		private static bool _inputBlocked;

		public static void Open(string listingId, string listingName)
		{
			_listingId = listingId;
			_listingName = listingName;
			_offers = new List<ZoneBlueprintStoreOfferDto>();
			_scrollOffset = 0;
			EnsurePanel();
			if ((Object)(object)_panel != (Object)null && Object.op_Implicit((Object)(object)_panel))
			{
				_panel.SetActive(true);
				UpdateBackButtonLabel();
				RefreshRows();
				SetStatus(HomesteadLocalization.Text("hs_store_loading_offers"));
				SetInputBlocked(blocked: true);
			}
		}

		public static void ResetForWorldSession()
		{
			_listingId = "";
			_listingName = "";
			_offers = new List<ZoneBlueprintStoreOfferDto>();
			_scrollOffset = 0;
			if ((Object)(object)_panel != (Object)null && Object.op_Implicit((Object)(object)_panel))
			{
				_panel.SetActive(false);
			}
			SetInputBlocked(blocked: false);
		}

		public static void SetOffers(ZoneBlueprintStoreListOffersResponse response)
		{
			EnsurePanel();
			_listingId = response.ListingId;
			_listingName = response.ListingName;
			_offers = response.Offers ?? new List<ZoneBlueprintStoreOfferDto>();
			_scrollOffset = 0;
			UpdateBackButtonLabel();
			RefreshRows();
			SetStatus(response.Success ? BuildStatus() : response.Message);
			if ((Object)(object)_panel != (Object)null && Object.op_Implicit((Object)(object)_panel))
			{
				_panel.SetActive(true);
				SetInputBlocked(blocked: true);
			}
		}

		public static void RefreshCurrent()
		{
			if (!string.IsNullOrWhiteSpace(_listingId))
			{
				ZoneBlueprintStore.RequestOfferList(_listingId);
			}
		}

		public static void Update()
		{
			if (_inputBlocked && !IsPanelVisible())
			{
				SetInputBlocked(blocked: false);
			}
			if (!IsPanelVisible())
			{
				return;
			}
			ZoneBlueprintStorePanelLayout.Apply(_panel, ZoneBlueprintStorePanelKind.Large);
			if (Input.GetKeyDown((KeyCode)27))
			{
				Close();
				return;
			}
			UpdateBackButtonLabel();
			if (BlueprintConfig.IsStoreBackHotkeyDown())
			{
				BackToStore();
				return;
			}
			float axis = Input.GetAxis("Mouse ScrollWheel");
			if (Mathf.Abs(axis) > 0.05f)
			{
				int num = ((axis < 0f) ? 6 : (-6));
				int num2 = Mathf.Clamp(_scrollOffset + num, 0, Mathf.Max(0, _offers.Count - 6));
				if (num2 != _scrollOffset)
				{
					_scrollOffset = num2;
					RefreshRows();
				}
			}
		}

		private static void EnsurePanel()
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: 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_00d7: 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_00f5: 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_0109: 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_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: 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_0170: 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_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: 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_0218: 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_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: Expected O, but got Unknown
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: 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_06cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_06dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_06eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0734: Unknown result type (might be due to invalid IL or missing references)
			//IL_0743: Unknown result type (might be due to invalid IL or missing references)
			//IL_0752: Unknown result type (might be due to invalid IL or missing references)
			//IL_0327: Unknown result type (might be due to invalid IL or missing references)
			//IL_030c: Unknown result type (might be due to invalid IL or missing references)
			//IL_07b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0781: Unknown result type (might be due to invalid IL or missing references)
			//IL_0786: Unknown result type (might be due to invalid IL or missing references)
			//IL_078c: Expected O, but got Unknown
			//IL_0355: Unknown result type (might be due to invalid IL or missing references)
			//IL_0364: Unknown result type (might be due to invalid IL or missing references)
			//IL_0373: Unknown result type (might be due to invalid IL or missing references)
			//IL_0381: Unknown result type (might be due to invalid IL or missing references)
			//IL_0387: Unknown result type (might be due to invalid IL or missing references)
			//IL_03be: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0427: Unknown result type (might be due to invalid IL or missing references)
			//IL_0436: Unknown result type (might be due to invalid IL or missing references)
			//IL_0445: Unknown result type (might be due to invalid IL or missing references)
			//IL_0453: Unknown result type (might be due to invalid IL or missing references)
			//IL_0459: Unknown result type (might be due to invalid IL or missing references)
			//IL_049f: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_052f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0539: Expected O, but got Unknown
			//IL_0557: Unknown result type (might be due to invalid IL or missing references)
			//IL_0566: Unknown result type (might be due to invalid IL or missing references)
			//IL_0575: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b0: Expected O, but got Unknown
			//IL_05ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_05dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_061d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0627: Expected O, but got Unknown
			//IL_0640: Unknown result type (might be due to invalid IL or missing references)
			//IL_064f: Unknown result type (might be due to invalid IL or missing references)
			//IL_065e: Unknown result type (might be due to invalid IL or missing references)
			//IL_068f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0699: Expected O, but got Unknown
			//IL_0828: Unknown result type (might be due to invalid IL or missing references)
			//IL_0837: Unknown result type (might be due to invalid IL or missing references)
			//IL_0846: Unknown result type (might be due to invalid IL or missing references)
			//IL_0802: Unknown result type (might be due to invalid IL or missing references)
			//IL_0807: Unknown result type (might be due to invalid IL or missing references)
			//IL_080d: Expected O, but got Unknown
			//IL_0874: Unknown result type (might be due to invalid IL or missing references)
			//IL_0879: Unknown result type (might be due to invalid IL or missing references)
			//IL_087f: Expected O, but got Unknown
			if (((Object)(object)_panel != (Object)null && Object.op_Implicit((Object)(object)_panel)) || (Object)(object)GUIManager.CustomGUIFront == (Object)null)
			{
				return;
			}
			Rows.Clear();
			RowWidgets.Clear();
			GUIManager instance = GUIManager.Instance;
			_panel = ZoneBlueprintStorePanelLayout.CreatePanel(instance, GUIManager.CustomGUIFront.transform, ZoneBlueprintStorePanelKind.Large, "HomesteadBlueprintStoreOffersPanel");
			Transform transform = _panel.transform;
			instance.CreateText(HomesteadLocalization.Text("hs_store_offers_title"), transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -28f), instance.AveriaSerifBold, 21, instance.ValheimOrange, true, Color.black, 640f, 28f, false);
			_titleText = instance.CreateText("", transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -58f), instance.AveriaSerif, 14, instance.ValheimBeige, true, Color.black, 640f, 24f, false).GetComponent<Text>();
			instance.CreateText(HomesteadLocalization.Text("hs_store_col_buyer"), transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(-300f, -88f), instance.AveriaSerifBold, 13, instance.ValheimOrange, true, Color.black, 120f, 20f, false);
			instance.CreateText(HomesteadLocalization.Text("hs_store_col_offer"), transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(-112f, -88f), instance.AveriaSerifBold, 13, instance.ValheimOrange, true, Color.black, 260f, 20f, false);
			instance.CreateText(HomesteadLocalization.Text("hs_store_col_status"), transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(110f, -88f), instance.AveriaSerifBold, 13, instance.ValheimOrange, true, Color.black, 90f, 20f, false);
			for (int i = 0; i < 6; i++)
			{
				GameObject val = new GameObject($"OfferRow{i}");
				val.transform.SetParent(transform, false);
				RectTransform obj = val.AddComponent<RectTransform>();
				obj.anchorMin = new Vector2(0.5f, 1f);
				obj.anchorMax = new Vector2(0.5f, 1f);
				obj.pivot = new Vector2(0.5f, 1f);
				obj.anchoredPosition = new Vector2(0f, -114f - (float)i * 58f);
				obj.sizeDelta = new Vector2(840f, 52f);
				((Graphic)val.AddComponent<Image>()).color = ((i % 2 == 0) ? new Color(0.05f, 0.045f, 0.035f, 0.32f) : new Color(0.02f, 0.018f, 0.014f, 0.22f));
				int index = i;
				OfferRowWidgets offerRowWidgets = new OfferRowWidgets
				{
					Buyer = instance.CreateText("", val.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(-300f, -26f), instance.AveriaSerif, 13, instance.ValheimBeige, true, Color.black, 120f, 24f, false).GetComponent<Text>(),
					Price = instance.CreateText("", val.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(-112f, -26f), instance.AveriaSerif, 12, instance.ValheimBeige, true, Color.black, 260f, 36f, false).GetComponent<Text>(),
					Status = instance.CreateText("", val.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(108f, -26f), instance.AveriaSerifBold, 13, instance.ValheimYellow, true, Color.black, 90f, 24f, false).GetComponent<Text>()
				};
				((Component)offerRowWidgets.Price).gameObject.SetActive(false);
				ZoneBlueprintStorePriceIconStrip.CreateSlots(instance, val.transform, 8, new Vector2(-204f, -17f), 46f, -25f, 4, offerRowWidgets.PriceIcons, offerRowWidgets.PriceAmounts);
				offerRowWidgets.BuyButton = instance.CreateButton(HomesteadLocalization.Text("hs_common_buy"), val.transform, new Vector2(1f, 0.5f), new Vector2(1f, 0.5f), new Vector2(-218f, 0f), 50f, 30f).GetComponent<Button>();
				((UnityEvent)offerRowWidgets.BuyButton.onClick).AddListener((UnityAction)delegate
				{
					Buy(index);
				});
				offerRowWidgets.AcceptButton = instance.CreateButton(HomesteadLocalization.Text("hs_common_accept"), val.transform, new Vector2(1f, 0.5f), new Vector2(1f, 0.5f), new Vector2(-158f, 0f), 62f, 30f).GetComponent<Button>();
				((UnityEvent)offerRowWidgets.AcceptButton.onClick).AddListener((UnityAction)delegate
				{
					Decide(index, "accept");
				});
				offerRowWidgets.DeclineButton = instance.CreateButton(HomesteadLocalization.Text("hs_common_decline"), val.transform, new Vector2(1f, 0.5f), new Vector2(1f, 0.5f), new Vector2(-88f, 0f), 66f, 30f).GetComponent<Button>();
				((UnityEvent)offerRowWidgets.DeclineButton.onClick).AddListener((UnityAction)delegate
				{
					Decide(index, "decline");
				});
				offerRowWidgets.DeleteButton = instance.CreateButton("X", val.transform, new Vector2(1f, 0.5f), new Vector2(1f, 0.5f), new Vector2(-34f, 0f), 28f, 30f).GetComponent<Button>();
				((UnityEvent)offerRowWidgets.DeleteButton.onClick).AddListener((UnityAction)delegate
				{
					Delete(index);
				});
				RowWidgets.Add(offerRowWidgets);
				Rows.Add(val);
			}
			_statusText = instance.CreateText("", transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -506f), instance.AveriaSerif, 13, instance.ValheimYellow, true, Color.black, 640f, 28f, false).GetComponent<Text>();
			Button component = instance.CreateButton(HomesteadLocalization.Text("hs_common_back"), transform, new Vector2(0f, 1f), new Vector2(0f, 1f), new Vector2(108f, -548f), 170f, 34f).GetComponent<Button>();
			ButtonClickedEvent onClick = component.onClick;
			object obj2 = <>O.<0>__BackToStore;
			if (obj2 == null)
			{
				UnityAction val2 = BackToStore;
				<>O.<0>__BackToStore = val2;
				obj2 = (object)val2;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj2);
			_backButtonText = ((Component)component).GetComponentInChildren<Text>();
			UpdateBackButtonLabel();
			ButtonClickedEvent onClick2 = instance.CreateButton(HomesteadLocalization.Text("hs_common_refresh"), transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -548f), 128f, 34f).GetComponent<Button>().onClick;
			object obj3 = <>O.<1>__RefreshCurrent;
			if (obj3 == null)
			{
				UnityAction val3 = RefreshCurrent;
				<>O.<1>__RefreshCurrent = val3;
				obj3 = (object)val3;
			}
			((UnityEvent)onClick2).AddListener((UnityAction)obj3);
			ButtonClickedEvent onClick3 = instance.CreateButton(HomesteadLocalization.Text("hs_common_close"), transform, new Vector2(1f, 1f), new Vector2(1f, 1f), new Vector2(-82f, -548f), 128f, 34f).GetComponent<Button>().onClick;
			object obj4 = <>O.<2>__Close;
			if (obj4 == null)
			{
				UnityAction val4 = Close;
				<>O.<2>__Close = val4;
				obj4 = (object)val4;
			}
			((UnityEvent)onClick3).AddListener((UnityAction)obj4);
		}

		private static void RefreshRows()
		{
			if ((Object)(object)_titleText != (Object)null && Object.op_Implicit((Object)(object)_titleText))
			{
				_titleText.text = _listingName;
			}
			_scrollOffset = Mathf.Clamp(_scrollOffset, 0, Mathf.Max(0, _offers.Count - 6));
			for (int i = 0; i < Rows.Count; i++)
			{
				int num = _scrollOffset + i;
				bool flag = num < _offers.Count;
				Rows[i].SetActive(flag);
				if (flag)
				{
					ZoneBlueprintStoreOfferDto zoneBlueprintStoreOfferDto = _offers[num];
					OfferRowWidgets offerRowWidgets = RowWidgets[i];
					offerRowWidgets.Buyer.text = zoneBlueprintStoreOfferDto.BuyerName;
					offerRowWidgets.Price.text = zoneBlueprintStoreOfferDto.PriceText;
					offerRowWidgets.Status.text = zoneBlueprintStoreOfferDto.Status;
					ZoneBlueprintStorePriceIconStrip.Refresh(zoneBlueprintStoreOfferDto.PriceItems, 8, offerRowWidgets.PriceIcons, offerRowWidgets.PriceAmounts);
					((Component)offerRowWidgets.BuyButton).gameObject.SetActive(zoneBlueprintStoreOfferDto.CanBuy);
					((Component)offerRowWidgets.AcceptButton).gameObject.SetActive(zoneBlueprintStoreOfferDto.CanAccept);
					((Component)offerRowWidgets.DeclineButton).gameObject.SetActive(zoneBlueprintStoreOfferDto.CanDecline);
					((Component)offerRowWidgets.DeleteButton).gameObject.SetActive(zoneBlueprintStoreOfferDto.CanDelete);
				}
			}
		}

		private static void Buy(int index)
		{
			int num = _scrollOffset + index;
			if (num >= 0 && num < _offers.Count)
			{
				ZoneBlueprintStoreOfferDto zoneBlueprintStoreOfferDto = _offers[num];
				Close();
				ZoneBlueprintStore.RequestPreviewOffer(zoneBlueprintStoreOfferDto.ListingId, zoneBlueprintStoreOfferDto.OfferId);
			}
		}

		private static void Decide(int index, string decision)
		{
			int num = _scrollOffset + index;
			if (num >= 0 && num < _offers.Count)
			{
				ZoneBlueprintStoreOfferDto zoneBlueprintStoreOfferDto = _offers[num];
				ZoneBlueprintStore.RequestOfferDecision(zoneBlueprintStoreOfferDto.ListingId, zoneBlueprintStoreOfferDto.OfferId, decision);
			}
		}

		private static void Delete(int index)
		{
			int num = _scrollOffset + index;
			if (num >= 0 && num < _offers.Count)
			{
				ZoneBlueprintStoreOfferDto zoneBlueprintStoreOfferDto = _offers[num];
				ZoneBlueprintStore.RequestDeleteOffer(zoneBlueprintStoreOfferDto.ListingId, zoneBlueprintStoreOfferDto.OfferId);
			}
		}

		private static void BackToStore()
		{
			Close();
			ZoneBlueprintStore.Open(Player.m_localPlayer);
		}

		private static void UpdateBackButtonLabel()
		{
			if (!((Object)(object)_backButtonText == (Object)null) && Object.op_Implicit((Object)(object)_backButtonText))
			{
				string storeBackHotkeyLabel = BlueprintConfig.StoreBackHotkeyLabel;
				_backButtonText.text = (string.Equals(storeBackHotkeyLabel, "None", StringComparison.OrdinalIgnoreCase) ? HomesteadLocalization.Text("hs_common_back") : HomesteadLocalization.Format("hs_common_back_with_key", storeBackHotkeyLabel));
			}
		}

		private static string BuildStatus()
		{
			if (_offers.Count == 0)
			{
				return HomesteadLocalization.Text("hs_store_no_offers");
			}
			int num = _scrollOffset + 1;
			int num2 = Mathf.Min(_scrollOffset + 6, _offers.Count);
			return HomesteadLocalization.Format("hs_store_offers_status", num, num2, _offers.Count);
		}

		private static void SetStatus(string text)
		{
			if ((Object)(object)_statusText != (Object)null && Object.op_Implicit((Object)(object)_statusText))
			{
				_statusText.text = text;
			}
		}

		private static void Close()
		{
			if ((Object)(object)_panel != (Object)null && Object.op_Implicit((Object)(object)_panel))
			{
				_panel.SetActive(false);
			}
			SetInputBlocked(blocked: false);
		}

		private static bool IsPanelVisible()
		{
			if ((Object)(object)_panel != (Object)null && Object.op_Implicit((Object)(object)_panel))
			{
				return _panel.activeInHierarchy;
			}
			return false;
		}

		private static void SetInputBlocked(bool blocked)
		{
			if (_inputBlocked != blocked)
			{
				GUIManager.BlockInput(blocked);
				_inputBlocked = blocked;
			}
		}
	}
	internal enum ZoneBlueprintStorePanelKind
	{
		Large,
		Form
	}
	internal static class ZoneBlueprintStorePanelLayout
	{
		private const float SaveDelay = 0.75f;

		private const float PositionEpsilon = 0.5f;

		private static bool _dirtyLarge;

		private static bool _dirtyForm;

		private static float _nextSaveTime;

		private static Vector2 _pendingLargeOffset;

		private static Vector2 _pendingFormOffset;

		public static GameObject CreatePanel(GUIManager gui, Transform parent, ZoneBlueprintStorePanelKind kind, string name)
		{
			//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)
			//IL_0013: 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_0028: 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_0033: Unknown result type (might be due to invalid IL or missing references)
			Vector2 size = GetSize(kind);
			GameObject obj = gui.CreateWoodpanel(parent, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), GetOffset(kind), size.x, size.y, true);
			((Object)obj).name = name;
			ApplyStored(obj, kind);
			return obj;
		}

		public static void Apply(GameObject? panel, ZoneBlueprintStorePanelKind kind)
		{
			//IL_0018: 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_003e: 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_0044: 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_0058: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)panel == (Object)null || !Object.op_Implicit((Object)(object)panel))
			{
				return;
			}
			panel.transform.localScale = Vector3.one * GetScale(kind);
			RectTransform component = panel.GetComponent<RectTransform>();
			if ((Object)(object)component != (Object)null)
			{
				Vector2 anchoredPosition = component.anchoredPosition;
				if (Vector2.Distance(anchoredPosition, GetOffset(kind)) > 0.5f)
				{
					MarkOffset(kind, anchoredPosition);
				}
			}
			SaveIfDue();
		}

		public static void ApplyStored(GameObject? panel, ZoneBlueprintStorePanelKind kind)
		{
			//IL_0034: 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_0024: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)panel == (Object)null) && Object.op_Implicit((Object)(object)panel))
			{
				RectTransform component = panel.GetComponent<RectTransform>();
				if ((Object)(object)component != (Object)null)
				{
					component.anchoredPosition = GetOffset(kind);
				}
				panel.transform.localScale = Vector3.one * GetScale(kind);
			}
		}

		public static void ResetOffsets()
		{
			//IL_0000: 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)
			BlueprintConfig.SetStoreLargePanelOffset(Vector2.zero);
			BlueprintConfig.SetStoreFormPanelOffset(Vector2.zero);
			_dirtyLarge = false;
			_dirtyForm = false;
		}

		private static Vector2 GetSize(ZoneBlueprintStorePanelKind kind)
		{
			//IL_001d: 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)
			if (kind != 0)
			{
				return new Vector2(620f, 500f);
			}
			return new Vector2(900f, 600f);
		}

		private static Vector2 GetOffset(ZoneBlueprintStorePanelKind kind)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			if (kind != 0)
			{
				return BlueprintConfig.StoreFormPanelOffset;
			}
			return BlueprintConfig.StoreLargePanelOffset;
		}

		private static void MarkOffset(ZoneBlueprintStorePanelKind kind, Vector2 offset)
		{
			//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_0006: 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_001a: 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_000c: Unknown result type (might be due to invalid IL or missing references)
			offset = ClampOffset(offset);
			if (kind == ZoneBlueprintStorePanelKind.Large)
			{
				_pendingLargeOffset = offset;
				_dirtyLarge = true;
			}
			else
			{
				_pendingFormOffset = offset;
				_dirtyForm = true;
			}
			_nextSaveTime = Time.unscaledTime + 0.75f;
		}

		private static float GetScale(ZoneBlueprintStorePanelKind kind)
		{
			if (kind != 0)
			{
				return BlueprintConfig.StoreFormPanelScale;
			}
			return BlueprintConfig.StoreLargePanelScale;
		}

		private static Vector2 ClampOffset(Vector2 offset)
		{
			//IL_0002: 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_0038: Unknown result type (might be due to invalid IL or missing references)
			offset.x = Mathf.Clamp(offset.x, -2000f, 2000f);
			offset.y = Mathf.Clamp(offset.y, -2000f, 2000f);
			return offset;
		}

		private static void SaveIfDue()
		{
			//IL_0022: 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)
			if ((_dirtyLarge || _dirtyForm) && !(Time.unscaledTime < _nextSaveTime))
			{
				if (_dirtyLarge)
				{
					BlueprintConfig.SetStoreLargePanelOffset(_pendingLargeOffset);
					_dirtyLarge = false;
				}
				if (_dirtyForm)
				{
					BlueprintConfig.SetStoreFormPanelOffset(_pendingFormOffset);
					_dirtyForm = false;
				}
			}
		}
	}
	internal sealed class ZoneBlueprintStorePreviewTool : MonoBehaviour
	{
		private enum PreviewMode
		{
			Purchase,
			Listing
		}

		private sealed class LockedPreview
		{
			public GameObject? Root;

			public Material? Material;

			public string Mode = "";

			public string ListingId = "";

			public string OfferId = "";

			public string BlueprintName = "";
		}

		private const float MaxPreviewDistance = 128f;

		private static ZoneBlueprintStorePreviewTool? _instance;

		private readonly Dictionary<string, LockedPreview> _lockedPreviews = new Dictionary<string, LockedPreview>(StringComparer.Ordinal);

		private readonly Dictionary<string, Queue<string>> _pendingListingPreviewKeysByName = new Dictionary<string, Queue<string>>(StringComparer.OrdinalIgnoreCase);

		private string _listingId = "";

		private string _offerId = "";

		private string _name = "";

		private ZoneBlueprintFile? _blueprint;

		private GameObject? _previewRoot;

		private GameObject? _chestPreviewRoot;

		private Material? _lockedPreviewMaterial;

		private float _yaw;

		private float _heightOffset;

		private Vector3 _horizontalOffset;

		private Vector3 _currentAnchor;

		private Quaternion _currentRotation;

		private Vector3 _currentChestPosition;

		private Quaternion _currentChestRotation;

		private bool _allowPurchase;

		private bool _active;

		private bool _placementLocked;

		private bool _lockedPreviewMaterialApplied;

		private bool _waitForPlaceRelease;

		private int _activatedFrame;

		private int _lockedPreviewSequence;

		private string _lockedPreviewColorSignature = "";

		private PreviewMode _mode;

		public static void Activate(string listingId, string name, ZoneBlueprintFile blueprint, bool allowPurchase)
		{
			EnsureInstance();
			_instance?.ActivateInternal(PreviewMode.Purchase, listingId, "", name, blueprint, allowPurchase);
		}

		public static void Activate(string listingId, string offerId, string name, ZoneBlueprintFile blueprint, bool allowPurchase)
		{
			EnsureInstance();
			_instance?.ActivateInternal(PreviewMode.Purchase, listingId, offerId, name, blueprint, allowPurchase);
		}

		public static void ActivateListing(string name, ZoneBlueprintFile blueprint)
		{
			EnsureInstance();
			_instance?.ActivateInternal(PreviewMode.Listing, "", "", name, blueprint, allowPurchase: false);
		}

		public static void DeactivateActive()
		{
			ZoneBlueprintStorePreviewTool? instance = _instance;
			if (instance == null || !instance._placementLocked)
			{
				_instance?.Deactivate();
			}
		}

		public static void ForceDeactivateActive()
		{
			_instance?.Deactivate();
		}

		public static void UnlockActivePlacement()
		{
			if ((Object)(object)_instance != (Object)null && Object.op_Implicit((Object)(object)_instance))
			{
				_instance._placementLocked = false;
				_instance.RestoreUnlockedPreview();
			}
		}

		public static void NotifyStoreChestDestroyed(string mode, string listingId, string blueprintName)
		{
			if ((Object)(object)_instance == (Object)null || !Object.op_Implicit((Object)(object)_instance))
			{
				return;
			}
			if (string.Equals(mode, "buy", StringComparison.Ordinal) && !string.IsNullOrWhiteSpace(listingId))
			{
				_instance.RemoveLockedPreviewsByPrefix(PurchasePreviewPrefix(listingId));
			}
			else if (string.Equals(mode, "price", StringComparison.Ordinal))
			{
				if (!string.IsNullOrWhiteSpace(listingId))
				{
					_instance.RemoveLockedPreview(ListingPreviewKey(listingId));
				}
				else
				{
					_instance.CancelPendingListingPreview(blueprintName);
				}
			}
		}

		public static void ConfirmPendingListingPreview(string blueprintName, string listingId)
		{
			if (!((Object)(object)_instance == (Object)null) && Object.op_Implicit((Object)(object)_instance) && !string.IsNullOrWhiteSpace(listingId))
			{
				_instance.ConfirmPendingListingPreviewInternal(blueprintName, listingId);
			}
		}

		public static void RemoveListingPreview(string listingId)
		{
			if (!((Object)(object)_instance == (Object)null) && Object.op_Implicit((Object)(object)_instance) && !string.IsNullOrWhiteSpace(listingId))
			{
				_instance.RemoveLockedPreview(ListingPreviewKey(listingId));
			}
		}

		public static void RemovePurchasePreview(string listingId)
		{
			RemovePurchasePreview(listingId, "");
		}

		public static void RemovePurchasePreview(string listingId, string offerId)
		{
			if (!((Object)(object)_instance == (Object)null) && Object.op_Implicit((Object)(object)_instance) && !string.IsNullOrWhiteSpace(listingId))
			{
				if (!string.IsNullOrWhiteSpace(offerId))
				{
					_instance.RemoveLockedPreview(PurchasePreviewKey(listingId, offerId));
				}
				else
				{
					_instance.RemoveLockedPreviewsByPrefix(PurchasePreviewPrefix(listingId));
				}
			}
		}

		public static void CancelPendingPlacement(string action, string listingId, string blueprintName)
		{
			if ((Object)(object)_instance == (Object)null || !Object.op_Implicit((Object)(object)_instance))
			{
				return;
			}
			if (string.Equals(action, "buy", StringComparison.Ordinal))
			{
				if (!string.IsNullOrWhiteSpace(listingId))
				{
					_instance.RemoveLockedPreviewsByPrefix(PurchasePreviewPrefix(listingId));
				}
			}
			else if (string.Equals(action, "price_chest", StringComparison.Ordinal))
			{
				_instance.CancelPendingListingPreview(blueprintName);
			}
		}

		public static bool TryTransferPreviewToChest(string mode, string listingId, string blueprintName, Transform owner, out GameObject? root, out Material? material)
		{
			root = null;
			material = null;
			if ((Object)(object)_instance == (Object)null || !Object.op_Implicit((Object)(object)_instance) || (Object)(object)owner == (Object)null)
			{
				return false;
			}
			return _instance.TryTransferPreviewToChestInternal(mode, listingId, blueprintName, owner, out root, out material);
		}

		internal static Material ApplyStorePreviewMaterial(GameObject root, Color color)
		{
			//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_0033: Expected O, but got Unknown
			Material val = new Material(Shader.Find("Sprites/Default") ?? Shader.Find("Unlit/Color") ?? Shader.Find("Standard"))
			{
				color = color
			};
			if ((Object)(object)root == (Object)null)
			{
				return val;
			}
			Renderer[] componentsInChildren = root.GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val2 in componentsInChildren)
			{
				Material[] sharedMaterials = val2.sharedMaterials;
				for (int j = 0; j < sharedMaterials.Length; j++)
				{
					sharedMaterials[j] = val;
				}
				val2.sharedMaterials = sharedMaterials;
				val2.shadowCastingMode = (ShadowCastingMode)0;
				val2.receiveShadows = false;
			}
			return val;
		}

		private static void EnsureInstance()
		{
			//IL_001f: 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_002a: Expected O, but got Unknown
			if (!((Object)(object)_instance != (Object)null) || !Object.op_Implicit((Object)(object)_instance))
			{
				GameObject val = new GameObject("HomesteadBlueprintStorePreviewTool");
				Object.DontDestroyOnLoad((Object)val);
				_instance = val.AddComponent<ZoneBlueprintStorePreviewTool>();
			}
		}

		private void ActivateInternal(PreviewMode mode, string listingId, string offerId, string name, ZoneBlueprintFile blueprint, bool allowPurchase)
		{
			//IL_0086: 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_008e: 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_00ae: Unknown result type (might be due to invalid IL or missing references)
			ClearPreview();
			_mode = mode;
			_listingId = listingId;
			_offerId = offerId ?? "";
			_name = name;
			_blueprint = blueprint;
			_allowPurchase = allowPurchase;
			_placementLocked = false;
			_lockedPreviewMaterialApplied = false;
			_waitForPlaceRelease = true;
			_activatedFrame = Time.frameCount;
			_lockedPreviewColorSignature = "";
			float yaw;
			if (!((Object)(object)Player.m_localPlayer != (Object)null))
			{
				yaw = 0f;
			}
			else
			{
				Quaternion rotation = ((Component)Player.m_localPlayer).transform.rotation;
				yaw = ((Quaternion)(ref rotation)).eulerAngles.y;
			}
			_yaw = yaw;
			_heightOffset = 0f;
			_horizontalOffset = Vector3.zero;
			_previewRoot = ZoneBlueprintVisuals.CreateBlueprintVisualRoot(blueprint, "HomesteadStorePreview_" + name);
			_previewRoot.transform.SetParent(((Component)this).transform, false);
			_chestPreviewRoot = ZoneBlueprintStoreChestPrefab.CreatePreview(GetChestPreviewMode());
			GameObject? chestPreviewRoot = _chestPreviewRoot;
			if (chestPreviewRoot != null)
			{
				chestPreviewRoot.transform.SetParent(((Component)this).transform, false);
			}
			GameObject? chestPreviewRoot2 = _chestPreviewRoot;
			if (chestPreviewRoot2 != null)
			{
				chestPreviewRoot2.SetActive(false);
			}
			_active = true;
		}

		private void Update()
		{
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: 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_0165: 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_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: 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_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: 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_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: 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_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_01d9: 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_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: 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_01fd: Unknown result type (might be due to invalid IL or missing references)
			if (!_active)
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				Deactivate();
				return;
			}
			if (!_placementLocked && !IsHoldingBuildTool(localPlayer))
			{
				Deactivate();
				return;
			}
			if (!_placementLocked && Input.GetKeyDown((KeyCode)27))
			{
				Deactivate();
				return;
			}
			if (_placementLocked)
			{
				UpdateLockedStatusHud();
				return;
			}
			float axis = Input.GetAxis("Mouse ScrollWheel");
			if (Mathf.Abs(axis) > 0.001f)
			{
				ZoneAreaCameraZoomGuard.SuppressWheelZoomThisFrame();
				_yaw = Mathf.Repeat(_yaw + ((axis > 0f) ? PlacementControlConfig.RotationStep : (0f - PlacementControlConfig.RotationStep)), 360f);
			}
			if (PlacementControlConfig.IsPlacementAdjustModifierHeld() && (Input.GetKeyDown((KeyCode)280) || Input.GetKeyDown((KeyCode)281)))
			{
				float num = (Input.GetKeyDown((KeyCode)280) ? 1f : (-1f));
				_heightOffset = RoundHeightOffset(_heightOffset + num * PlacementControlConfig.HeightStep);
			}
			Vector3 val = (PlacementControlConfig.IsPlacementAdjustModifierHeld() ? ZonePlacementOffset.GetArrowKeyLocalNudge() : Vector3.zero);
			if (((Vector3)(ref val)).sqrMagnitude > 0.0001f)
			{
				_horizontalOffset += val * PlacementControlConfig.HorizontalStep;
			}
			if (TryGetAimPoint(localPlayer, out var point) && (Object)(object)_previewRoot != (Object)null)
			{
				Quaternion val2 = Quaternion.Euler(0f, _yaw, 0f);
				Quaternion aimYawRotation = GetAimYawRotation(localPlayer);
				Vector3 val3 = point + ZonePlacementOffset.ToWorldOffset(val2, _horizontalOffset, _heightOffset);
				_previewRoot.SetActive(true);
				_previewRoot.transform.position = val3;
				_previewRoot.transform.rotation = val2;
				_currentAnchor = val3;
				_currentRotation = val2;
				_currentChestRotation = aimYawRotation;
				_currentChestPosition = GetChestPosition(val3, val2, aimYawRotation);
				UpdateChestPreview(visible: true);
				ZoneAreaToolStatusHud.ShowBlueprint(GetPreviewTitle(), _yaw, _horizontalOffset, _heightOffset);
				UpdatePlaceInputGuard();
				if (IsPlacePressed())
				{
					PlaceChest();
				}
			}
			else
			{
				GameObject? previewRoot = _previewRoot;
				if (previewRoot != null)
				{
					previewRoot.SetActive(false);
				}
				UpdateChestPreview(visible: false);
			}
		}

		private void PlaceChest()
		{
			//IL_0066: 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_0072: 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_003c: 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_0048: 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)
			if (_blueprint == null)
			{
				return;
			}
			string key = CreateLockedPreviewKey();
			RegisterCurrentLockedPreview(key);
			if (_mode == PreviewMode.Purchase)
			{
				if (!_allowPurchase)
				{
					RemoveLockedPreview(key);
					return;
				}
				ZoneBlueprintStore.RequestBuyAt(_listingId, _offerId, _currentChestPosition, _currentChestRotation, _currentAnchor, _currentRotation);
				FinishActivePlacementAfterLock();
			}
			else
			{
				ZoneBlueprintStore.OpenPriceChestAt(_name, _currentChestPosition, _currentChestRotation, _currentAnchor, _currentRotation);
				FinishActivePlacementAfterLock();
			}
		}

		private string CreateLockedPreviewKey()
		{
			if (_mode == PreviewMode.Purchase)
			{
				return PurchasePreviewKey(_listingId, _offerId);
			}
			string text = $"price_pending:{++_lockedPreviewSequence}";
			if (!_pendingListingPreviewKeysByName.TryGetValue(_name, out Queue<string> value))
			{
				value = new Queue<string>();
				_pendingListingPreviewKeysByName[_name] = value;
			}
			value.Enqueue(text);
			return text;
		}

		private void RegisterCurrentLockedPreview(string key)
		{
			if (!((Object)(object)_previewRoot == (Object)null))
			{
				ApplyLockedPreviewMaterial();
				RemoveLockedPreview(key);
				((Object)_previewRoot).name = "HomesteadStoreLockedPreview_" + key;
				_previewRoot.transform.SetParent(((Component)this).transform, true);
				_lockedPreviews[key] = new LockedPreview
				{
					Root = _previewRoot,
					Material = _lockedPreviewMaterial,
					Mode = ((_mode == PreviewMode.Purchase) ? "buy" : "price"),
					ListingId = ((_mode == PreviewMode.Purchase) ? _listingId : ""),
					OfferId = ((_mode == PreviewMode.Purchase) ? _offerId : ""),
					BlueprintName = _name
				};
				_previewRoot = null;
				_lockedPreviewMaterial = null;
				_lockedPreviewMaterialApplied = false;
				_lockedPreviewColorSignature = "";
			}
		}

		private void FinishActivePlacementAfterLock()
		{
			//IL_0049: 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)
			_active = false;
			_placementLocked = false;
			_allowPurchase = false;
			_blueprint = null;
			_listingId = "";
			_offerId = "";
			_name = "";
			_heightOffset = 0f;
			_horizontalOffset = Vector3.zero;
			_waitForPlaceRelease = false;
			_activatedFrame = -1;
			ZoneAreaToolStatusHud.Hide();
			ClearPreview();
		}

		private void ConfirmPendingListingPreviewInternal(string blueprintName, string listingId)
		{
			string text = DequeuePendingListingPreviewKey(blueprintName);
			if (text != null && _lockedPreviews.TryGetValue(text, out LockedPreview value))
			{
				_lockedPreviews.Remove(text);
				string key = ListingPreviewKey(listingId);
				RemoveLockedPreview(key);
				value.ListingId = listingId;
				_lockedPreviews[key] = value;
			}
		}

		private bool TryTransferPreviewToChestInternal(string mode, string listingId, string blueprintName, Transform owner, out GameObject? root, out Material? material)
		{
			root = null;
			material = null;
			string transferPreviewKey = GetTransferPreviewKey(mode, listingId, blueprintName);
			if (transferPreviewKey == null || !_lockedPreviews.TryGetValue(transferPreviewKey, out LockedPreview value))
			{
				return false;
			}
			_lockedPreviews.Remove(transferPreviewKey);
			root = value.Root;
			material = value.Material;
			if ((Object)(object)root != (Object)null)
			{
				return Object.op_Implicit((Object)(object)root);
			}
			return false;
		}

		private string? GetTransferPreviewKey(string mode, string listingId, string blueprintName)
		{
			if (string.Equals(mode, "buy", StringComparison.Ordinal))
			{
				string prefix = PurchasePreviewPrefix(listingId);
				return _lockedPreviews.Keys.FirstOrDefault((string key) => key.StartsWith(prefix, StringComparison.Ordinal));
			}
			if (!string.Equals(mode, "price", StringComparison.Ordinal))
			{
				return null;
			}
			if (!string.IsNullOrWhiteSpace(listingId))
			{
				string text = ListingPreviewKey(listingId);
				if (_lockedPreviews.ContainsKey(text))
				{
					return text;
				}
			}
			return DequeuePendingListingPreviewKey(blueprintName);
		}

		private void CancelPendingListingPreview(string blueprintName)
		{
			string text = DequeuePendingListingPreviewKey(blueprintName) ?? FindAnyPendingListingPreviewKey();
			if (text != null)
			{
				RemoveLockedPreview(text);
			}
		}

		private string? DequeuePendingListingPreviewKey(string blueprintName)
		{
			if (string.IsNullOrWhiteSpace(blueprintName) || !_pendingListingPreviewKeysByName.TryGetValue(blueprintName, out Queue<string> value))
			{
				return null;
			}
			while (value.Count > 0)
			{
				string text = value.Dequeue();
				if (_lockedPreviews.ContainsKey(text))
				{
					if (value.Count == 0)
					{
						_pendingListingPreviewKeysByName.Remove(blueprintName);
					}
					return text;
				}
			}
			_pendingListingPreviewKeysByName.Remove(blueprintName);
			return null;
		}

		private string? FindAnyPendingListingPreviewKey()
		{
			return _lockedPreviews.Keys.FirstOrDefault((string key) => key.StartsWith("price_pending:", StringComparison.Ordinal));
		}

		private void RemoveLockedPreview(string key)
		{
			if (!string.IsNullOrWhiteSpace(key) && _lockedPreviews.TryGetValue(key, out LockedPreview value))
			{
				if ((Object)(object)value.Root != (Object)null && Object.op_Implicit((Object)(object)value.Root))
				{
					Object.Destroy((Object)(object)value.Root);
				}
				if ((Object)(object)value.Material != (Object)null)
				{
					Object.Destroy((Object)(object)value.Material);
				}
				_lockedPreviews.Remove(key);
			}
		}

		private void ClearLockedPreviews()
		{
			foreach (string item in _lockedPreviews.Keys.ToList())
			{
				RemoveLockedPreview(item);
			}
			_pendingListingPreviewKeysByName.Clear();
		}

		private void RemoveLockedPreviewsByPrefix(string prefix)
		{
			string prefix2 = prefix;
			foreach (string item in _lockedPreviews.Keys.Where((string key) => key.StartsWith(prefix2, StringComparison.Ordinal)).ToList())
			{
				RemoveLockedPreview(item);
			}
		}

		private void UpdateLockedStatusHud()
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			ApplyLockedPreviewMaterial();
			if ((Object)(object)_previewRoot != (Object)null)
			{
				_previewRoot.SetActive(true);
			}
			UpdateChestPreview(visible: true);
			string text = ((_mode == PreviewMode.Purchase) ? HomesteadLocalization.Text("hs_store_preview_deposit_price") : HomesteadLocalization.Text("hs_store_preview_set_price"));
			ZoneAreaToolStatusHud.ShowBlueprint(GetPreviewTitle() + " - " + text, _yaw, _horizontalOffset, _heightOffset);
		}

		private string GetPreviewTitle()
		{
			if (_mode != 0)
			{
				return HomesteadLocalization.Format("hs_store_preview_listing_title", _name);
			}
			return HomesteadLocalization.Format("hs_store_preview_purchase_title", _name);
		}

		private string GetChestPreviewMode()
		{
			if (_mode != 0)
			{
				return "price";
			}
			return "buy";
		}

		private Vector3 GetChestPosition(Vector3 anchor, Quaternion anchorRotation, Quaternion chestRotation)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0008: 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_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_0023: Unknown result type (might be due to invalid IL or missing references)
			if (_blueprint == null)
			{
				return anchor + chestRotation * new Vector3(0f, 0f, 2.2f);
			}
			return ZoneBlueprintCommands.GetPlanChestPosition(_blueprint, anchor, anchorRotation, chestRotation);
		}

		private void UpdateChestPreview(bool visible)
		{
			//IL_0067: 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)
			if ((Object)(object)_chestPreviewRoot == (Object)null)
			{
				_chestPreviewRoot = ZoneBlueprintStoreChestPrefab.CreatePreview(GetChestPreviewMode());
				GameObject? chestPreviewRoot = _chestPreviewRoot;
				if (chestPreviewRoot != null)
				{
					chestPreviewRoot.transform.SetParent(((Component)this).transform, false);
				}
			}
			if (!((Object)(object)_chestPreviewRoot == (Object)null))
			{
				_chestPreviewRoot.SetActive(visible);
				if (visible)
				{
					_chestPreviewRoot.transform.position = _currentChestPosition;
					_chestPreviewRoot.transform.rotation = _currentChestRotation;
				}
			}
		}

		private void ApplyLockedPreviewMaterial()
		{
			//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_001e: 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 ((Object)(object)_previewRoot == (Object)null)
			{
				return;
			}
			Color lockedPreviewColor = GetLockedPreviewColor();
			string text = ColorUtility.ToHtmlStringRGBA(lockedPreviewColor);
			Material lockedPreviewMaterial = GetLockedPreviewMaterial(lockedPreviewColor);
			if (_lockedPreviewMaterialApplied && string.Equals(text, _lockedPreviewColorSignature, StringComparison.Ordinal))
			{
				lockedPreviewMaterial.color = lockedPreviewColor;
				return;
			}
			Renderer[] componentsInChildren = _previewRoot.GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				Material[] sharedMaterials = val.sharedMaterials;
				for (int j = 0; j < sharedMaterials.Length; j++)
				{
					sharedMaterials[j] = lockedPreviewMaterial;
				}
				val.sharedMaterials = sharedMaterials;
				val.shadowCastingMode = (ShadowCastingMode)0;
				val.receiveShadows = false;
			}
			_lockedPreviewMaterialApplied = true;
			_lockedPreviewColorSignature = text;
		}

		private Material GetLockedPreviewMaterial(Color color)
		{
			//IL_0014: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			if ((Object)(object)_lockedPreviewMaterial != (Object)null)
			{
				_lockedPreviewMaterial.color = color;
				return _lockedPreviewMaterial;
			}
			Shader val = Shader.Find("Sprites/Default") ?? Shader.Find("Unlit/Color") ?? Shader.Find("Standard");
			_lockedPreviewMaterial = new Material(val)
			{
				color = color
			};
			return _lockedPreviewMaterial;
		}

		private Color GetLockedPreviewColor()
		{
			//IL_000e: 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)
			if (_mode != 0)
			{
				return BlueprintConfig.StoreListingPreviewColor;
			}
			return BlueprintConfig.StorePurchasePreviewColor;
		}

		private static string PurchasePreviewKey(string listingId, string offerId)
		{
			return PurchasePreviewPrefix(listingId) + offerId;
		}

		private static string PurchasePreviewPrefix(string listingId)
		{
			return "buy:" + listingId + ":";
		}

		private static string ListingPreviewKey(string listingId)
		{
			return "price:" + listingId;
		}

		private void RestoreUnlockedPreview()
		{
			//IL_006e: 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)
			if (_lockedPreviewMaterialApplied && _blueprint != null)
			{
				if ((Object)(object)_previewRoot != (Object)null)
				{
					Object.Destroy((Object)(object)_previewRoot);
				}
				_previewRoot = ZoneBlueprintVisuals.CreateBlueprintVisualRoot(_blueprint, "HomesteadStorePreview_" + _name);
				_previewRoot.transform.SetParent(((Component)this).transform, false);
				_previewRoot.transform.position = _currentAnchor;
				_previewRoot.transform.rotation = _currentRotation;
				_lockedPreviewMaterialApplied = false;
				_lockedPreviewColorSignature = "";
			}
		}

		private void Deactivate()
		{
			//IL_0069: 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)
			_active = false;
			_listingId = "";
			_offerId = "";
			_name = "";
			_blueprint = null;
			_allowPurchase = false;
			_placementLocked = false;
			_lockedPreviewMaterialApplied = false;
			_waitForPlaceRelease = false;
			_activatedFrame = -1;
			_lockedPreviewColorSignature = "";
			_heightOffset = 0f;
			_horizontalOffset = Vector3.zero;
			ZoneAreaToolStatusHud.Hide();
			ClearPreview();
		}

		private void OnDestroy()
		{
			ClearPreview();
			ClearLockedPreviews();
			if ((Object)(object)_instance == (Object)(object)this)
			{
				_instance = null;
			}
		}

		private void ClearPreview()
		{
			if ((Object)(object)_previewRoot != (Object)null)
			{
				Object.Destroy((Object)(object)_previewRoot);
				_previewRoot = null;
			}
			if ((Object)(object)_chestPreviewRoot != (Object)null)
			{
				Object.Destroy((Object)(object)_chestPreviewRoot);
				_chestPreviewRoot = null;
			}
			if ((Object)(object)_lockedPreviewMaterial != (Object)null)
			{
				Object.Destroy((Object)(object)_lockedPreviewMaterial);
				_lockedPreviewMaterial = null;
			}
			_lockedPreviewMaterialApplied = false;
			_lockedPreviewColorSignature = "";
		}

		private static bool TryGetAimPoint(Player player, out Vector3 point)
		{
			//IL_0079: 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_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_0098: 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_002d: 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_004b: Unknown result type (might be due to invalid IL or missing references)
			Camera mainCamera = Utils.GetMainCamera();
			RaycastHit val = default(RaycastHit);
			if ((Object)(object)mainCamera != (Object)null && Physics.Raycast(mainCamera.ScreenPointToRay(new Vector3((float)Screen.width * 0.5f, (float)Screen.height * 0.5f)), ref val, 128f, -5, (QueryTriggerInteraction)1))
			{
				point = ((RaycastHit)(ref val)).point;
				if ((Object)(object)ZoneSystem.instance != (Object)null)
				{
					Vector3 val2 = default(Vector3);
					Biome val3 = default(Biome);
					BiomeArea val4 = default(BiomeArea);
					Heightmap val5 = default(Heightmap);
					ZoneSystem.instance.GetGroundData(ref point, ref val2, ref val3, ref val4, ref val5);
				}
				return true;
			}
			point = ((Component)player).transform.position + ((Component)player).transform.forward * 8f;
			return true;
		}

		private static Quaternion GetYawRotation(Quaternion rotation)
		{
			//IL_0007: 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)
			return Quaternion.Euler(0f, ((Quaternion)(ref rotation)).eulerAngles.y, 0f);
		}

		private static Quaternion GetAimYawRotation(Player player)
		{
			//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_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			Camera mainCamera = Utils.GetMainCamera();
			if ((Object)(object)mainCamera != (Object)null)
			{
				Vector3 forward = ((Component)mainCamera).transform.forward;
				forward.y = 0f;
				if (((Vector3)(ref forward)).sqrMagnitude > 0.0001f)
				{
					return Quaternion.LookRotation(((Vector3)(ref forward)).normalized, Vector3.up);
				}
			}
			return GetYawRotation(((Component)player).transform.rotation);
		}

		private void ResetOffsets()
		{
			//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)
			_heightOffset = 0f;
			_horizontalOffset = Vector3.zero;
		}

		private void UpdatePlaceInputGuard()
		{
			if (_waitForPlaceRelease && Time.frameCount != _activatedFrame && !IsPlaceInputHeld())
			{
				_waitForPlaceRelease = false;
			}
		}

		private bool IsPlacePressed()
		{
			if (!_waitForPlaceRelease)
			{
				return IsPlacePressedRaw();
			}
			return false;
		}

		private static bool IsPlacePressedRaw()
		{
			if (!ZInput.GetButtonDown("Attack") && !ZInput.GetButtonDown("JoyPlace"))
			{
				return Input.GetMouseButtonDown(0);
			}
			return true;
		}

		private static bool IsPlaceInputHeld()
		{
			if (!ZInput.GetButton("Attack") && !ZInput.GetButton("JoyPlace"))
			{
				return Input.GetMouseButton(0);
			}
			return true;
		}

		private static float RoundHeightOffset(float value)
		{
			return Mathf.Round(value * 1000f) / 1000f;
		}

		private static bool IsHoldingBuildTool(Player player)
		{
			return (Object)(object)((Humanoid)player).GetRightItem()?.m_shared?.m_buildPieces != (Object)null;
		}
	}
	internal static class ZoneBlueprintStorePriceEditorUi
	{
		private readonly struct PriceRow
		{
			public InputField ItemInput { get; }

			public InputField AmountInput { get; }

			public PriceRow(InputField itemInput, InputField amountInput)
			{
				ItemInput = itemInput;
				AmountInput = amountInput;
			}
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction <0>__List;

			public static UnityAction <1>__ClearRows;

			public static UnityAction <2>__Close;
		}

		private const int SlotCount = 8;

		private static GameObject? _panel;

		private static Text? _titleText;

		private static Text? _statusText;

		private static readonly List<PriceRow> Rows = new List<PriceRow>();

		private static ZoneBlueprintStoreChest? _chest;

		private static bool _inputBlocked;

		public static void Open(ZoneBlueprintStoreChest chest)
		{
			if (!((Object)(object)chest == (Object)null) && Object.op_Implicit((Object)(object)chest) && chest.IsPriceChest())
			{
				_chest = chest;
				EnsurePanel();
				LoadRowsFromChest();
				RefreshTitle();
				if ((Object)(object)_panel != (Object)null && Object.op_Implicit((Object)(object)_panel))
				{
					_panel.SetActive(true);
					SetStatus(HomesteadLocalization.Text("hs_store_price_editor_status"));
					SetInputBlocked(blocked: true);
				}
			}
		}

		public static void Update()
		{
			if (_inputBlocked && !IsPanelVisible())
			{
				SetInputBlocked(blocked: false);
			}
			if (IsPanelVisible())
			{
				ZoneBlueprintStorePanelLayout.Apply(_panel, ZoneBlueprintStorePanelKind.Form);
				if ((Object)(object)_chest == (Object)null || !Object.op_Implicit((Object)(object)_chest) || !_chest.IsPriceChest())
				{
					Close();
				}
				else if (Input.GetKeyDown((KeyCode)27))
				{
					Close();
				}
			}
		}

		private static void EnsurePanel()
		{
			//IL_0074: 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_0092: 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_00a6: 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_00dc: 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_00f9: 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)
			//IL_0134: 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)
			//IL_0160: 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_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: 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_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f5: 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_0339: Unknown result type (might be due to invalid IL or missing references)
			//IL_0348: Unknown result type (might be due to invalid IL or missing references)
			//IL_039c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_0376: Unknown result type (might be due to invalid IL or missing references)
			//IL_037b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0381: Expected O, but got Unknown
			//IL_040e: Unknown result type (might be due to invalid IL or missing references)
			//IL_041d: 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_03e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f3: Expected O, but got Unknown
			//IL_045a: 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_0465: Expected O, but got Unknown
			if ((!((Object)(object)_panel != (Object)null) || !Object.op_Implicit((Object)(object)_panel)) && !((Object)(object)GUIManager.CustomGUIFront == (Object)null))
			{
				Rows.Clear();
				GUIManager instance = GUIManager.Instance;
				_panel = ZoneBlueprintStorePanelLayout.CreatePanel(instance, GUIManager.CustomGUIFront.transform, ZoneBlueprintStorePanelKind.Form, "HomesteadBlueprintStorePriceEditor");
				Transform transform = _panel.transform;
				instance.CreateText(HomesteadLocalization.Text("hs_store_price_title"), transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -28f), instance.AveriaSerifBold, 21, instance.ValheimOrange, true, Color.black, 540f, 28f, false);
				_titleText = instance.CreateText("", transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -58f), instance.AveriaSerif, 14, instance.ValheimBeige, true, Color.black, 540f, 24f, false).GetComponent<Text>();
				instance.CreateText(HomesteadLocalization.Text("hs_store_item_prefab_or_name"), transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(-126f, -88f), instance.AveriaSerifBold, 13, instance.ValheimOrange, true, Color.black, 300f, 20f, false);
				instance.CreateText(HomesteadLocalization.Text("hs_store_amount"), transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(160f, -88f), instance.AveriaSerifBold, 13, instance.ValheimOrange, true, Color.black, 120f, 20f, false);
				for (int i = 0; i < 8; i++)
				{
					float num = -118f - (float)i * 35f;
					InputField component = instance.CreateInputField(transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(-126f, num), (ContentType)0, "", 13, 300f, 28f).GetComponent<InputField>();
					component.characterLimit = 64;
					InputField component2 = instance.CreateInputField(transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(160f, num), (ContentType)2, "", 13, 120f, 28f).GetComponent<InputField>();
					component2.characterLimit = 9;
					Rows.Add(new PriceRow(component, component2));
				}
				_statusText = instance.CreateText("", transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -410f), instance.AveriaSerif, 13, instance.ValheimYellow, true, Color.black, 540f, 36f, false).GetComponent<Text>();
				ButtonClickedEvent onClick = instance.CreateButton(HomesteadLocalization.Text("hs_common_list"), transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(-120f, -458f), 104f, 34f).GetComponent<Button>().onClick;
				object obj = <>O.<0>__List;
				if (obj == null)
				{
					UnityAction val = List;
					<>O.<0>__List = val;
					obj = (object)val;
				}
				((UnityEvent)onClick).AddListener((UnityAction)obj);
				ButtonClickedEvent onClick2 = instance.CreateButton(HomesteadLocalization.Text("hs_common_clear"), transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -458f), 104f, 34f).GetComponent<Button>().onClick;
				object obj2 = <>O.<1>__ClearRows;
				if (obj2 == null)
				{
					UnityAction val2 = ClearRows;
					<>O.<1>__ClearRows = val2;
					obj2 = (object)val2;
				}
				((UnityEvent)onClick2).AddListener((UnityAction)obj2);
				ButtonClickedEvent onClick3 = instance.CreateButton(HomesteadLocalization.Text("hs_common_close"), transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(120f, -458f), 104f, 34f).GetComponent<Button>().onClick;
				object obj3 = <>O.<2>__Close;
				if (obj3 == null)
				{
					UnityAction val3 = Close;
					<>O.<2>__Close = val3;
					obj3 = (object)val3;
				}
				((UnityEvent)onClick3).AddListener((UnityAction)obj3);
			}
		}

		private static void LoadRowsFromChest()
		{
			ClearRows(setStatus: false);
			if (!((Object)(object)_chest == (Object)null) && Object.op_Implicit((Object)(object)_chest))
			{
				List<ZoneBlueprintStorePriceItem> list = _chest.ReadPriceItems();
				for (int i = 0; i < Rows.Count && i < list.Count; i++)
				{
					Rows[i].ItemInput.text = list[i].PrefabName;
					Rows[i].AmountInput.text = list[i].Amount.ToString();
				}
			}
		}

		private static bool TryReadRows(bool requirePrice, out List<ZoneBlueprintStorePriceItem> priceItems)
		{
			priceItems = new List<ZoneBlueprintStorePriceItem>();
			foreach (PriceRow row in Rows)
			{
				string text = row.ItemInput.text.Trim();
				string text2 = row.AmountInput.text.Trim();
				if (!string.IsNullOrWhiteSpace(text) || !string.IsNullOrWhiteSpace(text2))
				{
					if (string.IsNullOrWhiteSpace(text))
					{
						SetStatus(HomesteadLocalization.Text("hs_store_item_required"));
						return false;
					}
					if (!int.TryParse(text2, out var result) || result <= 0)
					{
						SetStatus(HomesteadLocalization.Format("hs_store_amount_min", text));
						return false;
					}
					if (!ZoneBlueprintStore.TryResolvePriceItem(text, result, out ZoneBlueprintStorePriceItem item, out string reason))
					{
						SetStatus(reason);
						return false;
					}
					priceItems.Add(item);
				}
			}
			if (priceItems.Count == 0 && !requirePrice)
			{
				return true;
			}
			if (!ZoneBlueprintStore.TryValidatePriceItems(priceItems, out priceItems, out string reason2))
			{
				SetStatus(reason2);
				return false;
			}
			return true;
		}

		private static bool SaveCurrentRows(bool requirePrice)
		{
			if ((Object)(object)_chest == (Object)null || !Object.op_Implicit((Object)(object)_chest))
			{
				SetStatus(HomesteadLocalization.Text("hs_store_price_chest_gone"));
				return false;
			}
			if (!TryReadRows(requirePrice, out List<ZoneBlueprintStorePriceItem> priceItems))
			{
				return false;
			}
			_chest.SetPriceItems(priceItems);
			return true;
		}

		private static void List()
		{
			if (SaveCurrentRows(requirePrice: true) && !((Object)(object)_chest == (Object)null) && Object.op_Implicit((Object)(object)_chest))
			{
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer == (Object)null)
				{
					SetStatus(HomesteadLocalization.Text("hs_common_player_not_ready"));
					return;
				}
				_chest.TryConfirm(localPlayer);
				Close(saveCurrentRows: false);
			}
		}

		private static void ClearRows()
		{
			ClearRows(setStatus: true);
		}

		private static void ClearRows(bool setStatus)
		{
			foreach (PriceRow row in Rows)
			{
				row.ItemInput.text = "";
				row.AmountInput.text = "";
			}
			if (setStatus)
			{
				SetStatus(HomesteadLocalization.Text("hs_store_price_rows_cleared"));
			}
		}

		private static void RefreshTitle()
		{
			if (!((Object)(object)_titleText == (Object)null) && Object.op_Implicit((Object)(object)_titleText) && !((Object)(object)_chest == (Object)null) && Object.op_Implicit((Object)(object)_chest))
			{
				_titleText.text = _chest.GetBlueprintNameForUi();
			}
		}

		private static void SetStatus(string text)
		{
			if ((Object)(object)_statusText != (Object)null && Object.op_Implicit((Object)(object)_statusText))
			{
				_statusText.text = text;
			}
		}

		private static void Close()
		{
			Close(saveCurrentRows: true);
		}

		private static void Close(bool saveCurrentRows)
		{
			if (!saveCurrentRows || SaveCurrentRows(requirePrice: false))
			{
				if ((Object)(object)_panel != (Object)null && Object.op_Implicit((Object)(object)_panel))
				{
					_panel.SetActive(false);
				}
				_chest = null;
				SetInputBlocked(blocked: false);
			}
		}

		private static bool IsPanelVisible()
		{
			if ((Object)(object)_panel != (Object)null && Object.op_Implicit((Object)(object)_panel))
			{
				return _panel.activeInHierarchy;
			}
			return false;
		}

		private static void SetInputBlocked(bool blocked)
		{
			if (_inputBlocked != blocked)
			{
				GUIManager.BlockInput(blocked);
				_inputBlocked = blocked;
			}
		}
	}
	internal static class ZoneBlueprintStorePriceInputUi
	{
		private enum Mode
		{
			Offer,
			EditPrice
		}

		private readonly struct PriceRow
		{
			public InputField ItemInput { get; }

			public InputField AmountInput { get; }

			public PriceRow(InputField itemInput, InputField amountInput)
			{
				ItemInput = itemInput;
				AmountInput = amountInput;
			}
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction <0>__BackToStore;

			public static UnityAction <1>__Submit;

			public static UnityAction <2>__ClearRows;

			public static UnityAction <3>__Close;
		}

		private const int SlotCount = 8;

		private static GameObject? _panel;

		private static Text? _headerText;

		private static Text? _titleText;

		private static Text? _statusText;

		private static Button? _submitButton;

		private static Text? _backButtonText;

		private static readonly List<PriceRow> Rows = new List<PriceRow>();

		private static ZoneBlueprintStoreListingSummaryDto? _listing;

		private static Mode _mode;

		private static bool _inputBlocked;

		public static void OpenOffer(ZoneBlueprintStoreListingSummaryDto listing)
		{
			_listing = listing;
			_mode = Mode.Offer;
			EnsurePanel();
			ClearRows(setStatus: false);
			Show(HomesteadLocalization.Text("hs_store_make_offer"), HomesteadLocalization.Format("hs_store_offer_for", listing.Name), HomesteadLocalization.Text("hs_store_send_offer"), HomesteadLocalization.Text("hs_store_offer_status"));
		}

		public static void OpenEditPrice(ZoneBlueprintStoreListingSummaryDto listing)
		{
			_listing = listing;
			_mode = Mode.EditPrice;
			EnsurePanel();
			LoadRows(listing.PriceItems);
			Show(HomesteadLocalization.Text("hs_store_edit_price"), listing.Name, HomesteadLocalization.Text("hs_common_save"), HomesteadLocalization.Text("hs_store_edit_price_status"));
		}

		public static void Update()
		{
			if (_inputBlocked && !IsPanelVisible())
			{
				SetInputBlocked(blocked: false);
			}
			if (!IsPanelVisible())
			{
				return;
			}
			ZoneBlueprintStorePanelLayout.Apply(_panel, ZoneBlueprintStorePanelKind.Form);
			if (Input.GetKeyDown((KeyCode)27))
			{
				Close();
				return;
			}
			UpdateBackButtonLabel();
			if (BlueprintConfig.IsStoreBackHotkeyDown())
			{
				BackToStore();
			}
		}

		private static void EnsurePanel()
		{
			//IL_006f: 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: 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_00a1: 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_00e0: 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_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_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: 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_01a5: 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_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d6: 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_02f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_032e: Unknown result type (might be due to invalid IL or missing references)
			//IL_033d: Unknown result type (might be due to invalid IL or missing references)
			//IL_034c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_037b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0380: Unknown result type (might be due to invalid IL or missing references)
			//IL_0386: Expected O, but got Unknown
			//IL_0427: Unknown result type (might be due to invalid IL or missing references)
			//IL_0436: Unknown result type (might be due to invalid IL or missing references)
			//IL_0445: Unknown result type (might be due to invalid IL or missing references)
			//IL_0401: Unknown result type (might be due to invalid IL or missing references)
			//IL_0406: Unknown result type (might be due to invalid IL or missing references)
			//IL_040c: Expected O, but got Unknown
			//IL_0499: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0473: Unknown result type (might be due to invalid IL or missing references)
			//IL_0478: Unknown result type (might be due to invalid IL or missing references)
			//IL_047e: Expected O, but got Unknown
			//IL_04e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f0: Expected O, but got Unknown
			if ((!((Object)(object)_panel != (Object)null) || !Object.op_Implicit((Object)(object)_panel)) && !((Object)(object)GUIManager.CustomGUIFront == (Object)null))
			{
				Rows.Clear();
				GUIManager instance = GUIManager.Instance;
				_panel = ZoneBlueprintStorePanelLayout.CreatePanel(instance, GUIManager.CustomGUIFront.transform, ZoneBlueprintStorePanelKind.Form, "HomesteadBlueprintStorePriceInput");
				Transform transform = _panel.transform;
				_headerText = instance.CreateText("", transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -28f), instance.AveriaSerifBold, 21, instance.ValheimOrange, true, Color.black, 540f, 28f, false).GetComponent<Text>();
				_titleText = instance.CreateText("", transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -58f), instance.AveriaSerif, 14, instance.ValheimBeige, true, Color.black, 540f, 24f, false).GetComponent<Text>();
				instance.CreateText(HomesteadLocalization.Text("hs_store_item_prefab_or_name"), transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(-126f, -88f), instance.AveriaSerifBold, 13, instance.ValheimOrange, true, Color.black, 300f, 20f, false);
				instance.CreateText(HomesteadLocalization.Text("hs_store_amount"), transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(160f, -88f), instance.AveriaSerifBold, 13, instance.ValheimOrange, true, Color.black, 120f, 20f, false);
				for (int i = 0; i < 8; i++)
				{
					float num = -118f - (float)i * 35f;
					InputField component = instance.CreateInputField(transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(-126f, num), (ContentType)0, "", 13, 300f, 28f).GetComponent<InputField>();
					component.characterLimit = 64;
					InputField component2 = instance.CreateInputField(transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(160f, num), (ContentType)2, "", 13, 120f, 28f).GetComponent<InputField>();
					component2.characterLimit = 9;
					Rows.Add(new PriceRow(component, component2));
				}
				_statusText = instance.CreateText("", transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -410f), instance.AveriaSerif, 13, instance.ValheimYellow, true, Color.black, 540f, 36f, false).GetComponent<Text>();
				Button component3 = instance.CreateButton(HomesteadLocalization.Text("hs_common_back"), transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(-216f, -458f), 160f, 34f).GetComponent<Button>();
				ButtonClickedEvent onClick = component3.onClick;
				object obj = <>O.<0>__BackToStore;
				if (obj == null)
				{
					UnityAction val = BackToStore;
					<>O.<0>__BackToStore = val;
					obj = (object)val;
				}
				((UnityEvent)onClick).AddListener((UnityAction)obj);
				_backButtonText = ((Component)component3).GetComponentInChildren<Text>();
				_submitButton = instance.CreateButton(HomesteadLocalization.Text("hs_common_submit"), transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(-62f, -458f), 120f, 34f).GetComponent<Button>();
				ButtonClickedEvent onClick2 = _submitButton.onClick;
				object obj2 = <>O.<1>__Submit;
				if (obj2 == null)
				{
					UnityAction val2 = Submit;
					<>O.<1>__Submit = val2;
					obj2 = (object)val2;
				}
				((UnityEvent)onClick2).AddListener((UnityAction)obj2);
				ButtonClickedEvent onClick3 = instance.CreateButton(HomesteadLocalization.Text("hs_common_clear"), transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(78f, -458f), 104f, 34f).GetComponent<Button>().onClick;
				object obj3 = <>O.<2>__ClearRows;
				if (obj3 == null)
				{
					UnityAction val3 = ClearRows;
					<>O.<2>__ClearRows = val3;
					obj3 = (object)val3;
				}
				((UnityEvent)onClick3).AddListener((UnityAction)obj3);
				ButtonClickedEvent onClick4 = instance.CreateButton(HomesteadLocalization.Text("hs_common_close"), transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(198f, -458f), 104f, 34f).GetComponent<Button>().onClick;
				object obj4 = <>O.<3>__Close;
				if (obj4 == null)
				{
					UnityAction val4 = Close;
					<>O.<3>__Close = val4;
					obj4 = (object)val4;
				}
				((UnityEvent)onClick4).AddListener((UnityAction)obj4);
				UpdateBackButtonLabel();
			}
		}

		private static void Show(string header, string title, string submit, string status)
		{
			if ((Object)(object)_panel == (Object)null || !Object.op_Implicit((Object)(object)_panel))
			{
				return;
			}
			_panel.SetActive(true);
			if ((Object)(object)_headerText != (Object)null && Object.op_Implicit((Object)(object)_headerText))
			{
				_headerText.text = header;
			}
			if ((Object)(object)_titleText != (Object)null && Object.op_Implicit((Object)(object)_titleText))
			{
				_titleText.text = title;
			}
			if ((Object)(object)_submitButton != (Object)null && Object.op_Implicit((Object)(object)_submitButton))
			{
				Text componentInChildren = ((Component)_submitButton).GetComponentInChildren<Text>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					componentInChildren.text = submit;
				}
			}
			UpdateBackButtonLabel();
			SetStatus(status);
			SetInputBlocked(blocked: true);
		}

		private static void Submit()
		{
			if (_listing != null && TryReadRows(out List<ZoneBlueprintStorePriceItem> priceItems))
			{
				if (_mode == Mode.EditPrice)
				{
					ZoneBlueprintStore.RequestEditListingPrice(_listing.ListingId, priceItems);
				}
				else
				{
					ZoneBlueprintStore.RequestCreateOffer(_listing.ListingId, priceItems);
				}
				Close();
			}
		}

		private static void BackToStore()
		{
			Close();
			ZoneBlueprintStore.Open(Player.m_localPlayer);
		}

		private static void UpdateBackButtonLabel()
		{
			if (!((Object)(object)_backButtonText == (Object)null) && Object.op_Implicit((Object)(object)_backButtonText))
			{
				string storeBackHotkeyLabel = BlueprintConfig.StoreBackHotkeyLabel;
				_backButtonText.text = (string.Equals(storeBackHotkeyLabel, "None", StringComparison.OrdinalIgnoreCase) ? HomesteadLocalization.Text("hs_common_back") : HomesteadLocalization.Format("hs_common_back_with_key", storeBackHotkeyLabel));
			}
		}

		private static void LoadRows(IEnumerable<ZoneBlueprintStorePriceItem> priceItems)
		{
			ClearRows(setStatus: false);
			List<ZoneBlueprintStorePriceItem> list = ZoneBlueprintStore.NormalizePriceItems(priceItems).Take(8).ToList();
			for (int i = 0; i < Rows.Count && i < list.Count; i++)
			{
				Rows[i].ItemInput.text = list[i].PrefabName;
				Rows[i].AmountInput.text = list[i].Amount.ToString();
			}
		}

		private static bool TryReadRows(out List<ZoneBlueprintStorePriceItem> priceItems)
		{
			priceItems = new List<ZoneBlueprintStorePriceItem>();
			foreach (PriceRow row in Rows)
			{
				string text = row.ItemInput.text.Trim();
				string text2 = row.AmountInput.text.Trim();
				if (!string.IsNullOrWhiteSpace(text) || !string.IsNullOrWhiteSpace(text2))
				{
					if (string.IsNullOrWhiteSpace(text))
					{
						SetStatus(HomesteadLocalization.Text("hs_store_item_required"));
						return false;
					}
					if (!int.TryParse(text2, out var result) || result <= 0)
					{
						SetStatus(HomesteadLocalization.Format("hs_store_amount_min", text));
						return false;
					}
					if (!ZoneBlueprintStore.TryResolvePriceItem(text, result, out ZoneBlueprintStorePriceItem item, out string reason))
					{
						SetStatus(reason);
						return false;
					}
					priceItems.Add(item);
				}
			}
			if (!ZoneBlueprintStore.TryValidatePriceItems(priceItems, out priceItems, out string reason2))
			{
				SetStatus(reason2);
				return false;
			}
			return true;
		}

		private static void ClearRows()
		{
			ClearRows(setStatus: true);
		}

		private static void ClearRows(bool setStatus)
		{
			foreach (PriceRow row in Rows)
			{
				row.ItemInput.text = "";
				row.AmountInput.text = "";
			}
			if (setStatus)
			{
				SetStatus(HomesteadLocalization.Text("hs_store_rows_cleared"));
			}
		}

		private static void SetStatus(string text)
		{
			if ((Object)(object)_statusText != (Object)null && Object.op_Implicit((Object)(object)_statusText))
			{
				_statusText.text = text;
			}
		}

		private static void Close()
		{
			if ((Object)(object)_panel != (Object)null && Object.op_Implicit((Object)(object)_panel))
			{
				_panel.SetActive(false);
			}
			_listing = null;
			SetInputBlocked(blocked: false);
		}

		private static bool IsPanelVisible()
		{
			if ((Object)(object)_panel != (Object)null && Object.op_Implicit((Object)(object)_panel))
			{
				return _panel.activeInHierarchy;
			}
			return false;
		}

		private static void SetInputBlocked(bool blocked)
		{
			if (_inputBlocked != blocked)
			{
				GUIManager.BlockInput(blocked);
				_inputBlocked = blocked;
			}
		}
	}
	internal sealed class ZoneBlueprintStorePurchaseEscrow
	{
		private readonly Component _source;

		private readonly Func<IEnumerable<ZoneBlueprintRequirement>> _requirementsFactory;

		private readonly Func<string, int> _getDeposited;

		private readonly Action<ZoneBlueprintRequirement, int> _addDeposit;

		public ZoneBlueprintStorePurchaseEscrow(Component source, Func<IEnumerable<ZoneBlueprintRequirement>> requirementsFactory, Func<string, int> getDeposited, Action<ZoneBlueprintRequirement, int> addDeposit)
		{
			_source = source;
			_requirementsFactory = requirementsFactory;
			_getDeposited = getDeposited;
			_addDeposit = addDeposit;
		}

		public bool HasAllRequired(out string deposited)
		{
			return CreateSession().HasAllRequired(out deposited);
		}

		public int AcceptNeededOnly(Inventory sourceInventory, ItemData item, int requestedAmount)
		{
			return CreateSession().AcceptNeededOnly(sourceInventory, item, requestedAmount);
		}

		public int AcceptAllNeeded(Inventory sourceInventory, Func<ItemData, bool>? skip = null)
		{
			return CreateSession().AcceptAllNeeded(sourceInventory, skip);
		}

		public int PullNearbyContainers()
		{
			ZoneMaterialEscrow.Session session = CreateSession();
			return AzuCraftyBoxesCompat.PullMissingMaterials(_source, session.GetMissingRequirements(), delegate(ZoneBlueprintRequirement requirement, int amount)
			{
				session.AcceptPulled(requirement, amount);
			});
		}

		public ZoneMaterialEscrow.AbsorbResult AbsorbUnexpectedInventoryItems(Inventory inventory, Vector3 dropPosition, bool preferInventory)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return CreateSession().AbsorbUnexpectedInventoryItems(inventory, dropPosition, preferInventory);
		}

		public List<ZoneBlueprintRequirement> GetMissingRequirements()
		{
			return CreateSession().GetMissingRequirements();
		}

		public string FormatDeposited()
		{
			return CreateSession().FormatDeposited();
		}

		private ZoneMaterialEscrow.Session CreateSession()
		{
			return new ZoneMaterialEscrow.Session(_requirementsFactory(), _getDeposited, _addDeposit);
		}
	}
	internal static class ZoneBlueprintStorePriceIconStrip
	{
		public static void CreateSlots(GUIManager gui, Transform parent, int slotCount, Vector2 start, float columnStep, float rowStep, int columns, List<Image> icons, List<Text> amounts)
		{
			//IL_0013: 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_0041: 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_006f: 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: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
			Vector2 anchoredPosition = default(Vector2);
			for (int i = 0; i < slotCount; i++)
			{
				int num = i % columns;
				int num2 = i / columns;
				((Vector2)(ref anchoredPosition))..ctor(start.x + (float)num * columnStep, start.y + (float)num2 * rowStep);
				Image val = CreateImage(parent, $"PriceIcon{i}", anchoredPosition, new Vector2(24f, 24f));
				Text component = gui.CreateText("", ((Component)val).transform, new Vector2(1f, 0f), new Vector2(1f, 0f), new Vector2(6f, -1f), gui.AveriaSerifBold, 11, Color.white, true, Color.black, 34f, 14f, false).GetComponent<Text>();
				icons.Add(val);
				amounts.Add(component);
			}
		}

		public static void Refresh(IReadOnlyList<ZoneBlueprintStorePriceItem> priceItems, int slotCount, List<Image> icons, List<Text> amounts)
		{
			List<ZoneBlueprintStorePriceItem> list = ZoneBlueprintStore.NormalizePriceItems(priceItems).Take(slotCount).ToList();
			for (int i = 0; i < icons.Count; i++)
			{
				bool flag = i < list.Count;
				((Component)icons[i]).gameObject.SetActive(flag);
				((Component)amounts[i]).gameObject.SetActive(flag);
				if (flag)
				{
					ZoneBlueprintStorePriceItem zoneBlueprintStorePriceItem = list[i];
					icons[i].sprite = ZoneBlueprintStoreUi.GetItemIcon(zoneBlueprintStorePriceItem);
					icons[i].preserveAspect = true;
					amounts[i].text = ZoneBlueprintStoreUi.FormatAmount(zoneBlueprintStorePriceItem.Amount);
				}
			}
		}

		private static Image CreateImage(Transform parent, string name, Vector2 anchoredPosition, Vector2 size)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: 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_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: 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)
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 1f);
			component.anchorMax = new Vector2(0.5f, 1f);
			component.pivot = new Vector2(0.5f, 0.5f);
			component.anchoredPosition = anchoredPosition;
			component.sizeDelta = size;
			Image obj = val.AddComponent<Image>();
			((Graphic)obj).raycastTarget = false;
			return obj;
		}
	}
	internal readonly struct ZoneBlueprintStorePreviewDescriptor
	{
		public Vector3 Anchor { get; }

		public Quaternion Rotation { get; }

		public string BlueprintFile { get; }

		public ZoneBlueprintStorePreviewDescriptor(Vector3 anchor, Quaternion rotation, string blueprintFile)
		{
			//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_0008: 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)
			Anchor = anchor;
			Rotation = rotation;
			BlueprintFile = blueprintFile;
		}
	}
	internal static class ZoneBlueprintStorePreviewPayload
	{
		private const string PreviewAnchorValidKey = "hs_store_preview_anchor";

		private const string PreviewAnchorXKey = "hs_store_preview_anchor_x";

		private const string PreviewAnchorYKey = "hs_store_preview_anchor_y";

		private const string PreviewAnchorZKey = "hs_store_preview_anchor_z";

		private const string PreviewAnchorRotXKey = "hs_store_preview_anchor_rx";

		private const string PreviewAnchorRotYKey = "hs_store_preview_anchor_ry";

		private const string PreviewAnchorRotZKey = "hs_store_preview_anchor_rz";

		private const string PreviewAnchorRotWKey = "hs_store_preview_anchor_rw";

		public static bool CanCreateLocalPreview => (Object)(object)Player.m_localPlayer != (Object)null;

		public static void Write(ZDO zdo, Vector3 anchor, Quaternion rotation)
		{
			//IL_0012: 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_0034: 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_0056: 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_0078: Unknown result type (might be due to invalid IL or missing references)
			zdo.Set("hs_store_preview_anchor", true);
			zdo.Set("hs_store_preview_anchor_x", anchor.x);
			zdo.Set("hs_store_preview_anchor_y", anchor.y);
			zdo.Set("hs_store_preview_anchor_z", anchor.z);
			zdo.Set("hs_store_preview_anchor_rx", rotation.x);
			zdo.Set("hs_store_preview_anchor_ry", rotation.y);
			zdo.Set("hs_store_preview_anchor_rz", rotation.z);
			zdo.Set("hs_store_preview_anchor_rw", rotation.w);
		}

		public static bool TryRead(ZDO zdo, string blueprintFile, out ZoneBlueprintStorePreviewDescriptor descriptor)
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: 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_00ae: 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_00d8: 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)
			descriptor = default(ZoneBlueprintStorePreviewDescriptor);
			if (!zdo.GetBool("hs_store_preview_anchor", false) || string.IsNullOrWhiteSpace(blueprintFile))
			{
				return false;
			}
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(ReadRequiredFloat(zdo, "hs_store_preview_anchor_x"), ReadRequiredFloat(zdo, "hs_store_preview_anchor_y"), ReadRequiredFloat(zdo, "hs_store_preview_anchor_z"));
			Quaternion val2 = default(Quaternion);
			((Quaternion)(ref val2))..ctor(ReadRequiredFloat(zdo, "hs_store_preview_anchor_rx"), ReadRequiredFloat(zdo, "hs_store_preview_anchor_ry"), ReadRequiredFloat(zdo, "hs_store_preview_anchor_rz"), ReadRequiredFloat(zdo, "hs_store_preview_anchor_rw"));
			if (!IsFinite(val.x) || !IsFinite(val.y) || !IsFinite(val.z) || !IsFinite(val2.x) || !IsFinite(val2.y) || !IsFinite(val2.z) || !IsFinite(val2.w))
			{
				return false;
			}
			descriptor = new ZoneBlueprintStorePreviewDescriptor(val, val2, blueprintFile);
			return true;
		}

		private static float ReadRequiredFloat(ZDO zdo, string key)
		{
			return zdo.GetFloat(key, float.NaN);
		}

		private static bool IsFinite(float value)
		{
			if (!float.IsNaN(value))
			{
				return !float.IsInfinity(value);
			}
			return false;
		}

		public static ZoneBlueprintFile CreatePreviewBlueprint(ZoneBlueprintFile source)
		{
			ZoneBlueprintFile zoneBlueprintFile = new ZoneBlueprintFile
			{
				Version = source.Version,
				Name = source.Name,
				World = source.World,
				SavedAt = source.SavedAt,
				Radius = source.Radius,
				TerrainContacts = new List<ZoneBlueprintTerrainContact>()
			};
			foreach (ZoneBlueprintEntry entry in source.Entries)
			{
				zoneBlueprintFile.Entries.Add(new ZoneBlueprintEntry
				{
					SaveId = entry.SaveId,
					Prefab = entry.Prefab,
					LocalPos = entry.LocalPos.ToArray(),
					LocalRot = entry.LocalRot.ToArray(),
					Scale = entry.Scale.ToArray(),
					Data = ""
				});
			}
			return zoneBlueprintFile;
		}

		public static Material ApplyPreviewMaterial(GameObject root, Color color)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return ZoneBlueprintGhostOwner.ApplyMaterial(root, color, null);
		}
	}
	internal static class ZoneBlueprintStoreRuntime
	{
		public static void Initialize(ManualLogSource logger)
		{
			ZoneBlueprintStoreDraftRepository.Initialize(logger);
			ZoneBlueprintStoreChestPrefab.Initialize(logger);
		}

		public static void Update()
		{
			ZoneBlueprintStoreDraftRepository.Update();
			ZoneBlueprintStoreUi.Update();
			ZoneBlueprintStorePriceEditorUi.Update();
			ZoneBlueprintStorePriceInputUi.Update();
			ZoneBlueprintStoreOffersUi.Update();
			ZoneBlueprintStoreNotificationsUi.Update();
		}
	}
	internal static class ZoneBlueprintStoreUi
	{
		private sealed class StoreRowWidgets
		{
			public Image? Snapshot;

			public Text? Name;

			public Text? Seller;

			public Text? Purchases;

			public Button? Button;

			public Button? OfferButton;

			public Button? OffersButton;

			public Button? HideButton;

			public Button? DelistButton;

			public readonly List<Image> PriceIcons = new List<Image>();

			public readonly List<Text> PriceAmounts = new List<Text>();
		}

		private readonly struct SnapshotDecodeRequest
		{
			public string Key { get; }

			public string ListingId { get; }

			public string Name { get; }

			public string IconPngBase64 { get; }

			public SnapshotDecodeRequest(string key, string listingId, string name, string iconPngBase64)
			{
				Key = key;
				ListingId = listingId;
				Name = name;
				IconPngBase64 = iconPngBase64;
			}
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction <0>__RequestListings;

			public static UnityAction <1>__RequestWithdraw;

			public static UnityAction <2>__ToggleShowHidden;

			public static UnityAction <3>__Close;
		}

		private const int MaxRows = 6;

		private const int PriceSlots = 8;

		private const float ScrollWheelThreshold = 0.05f;

		private const float WithdrawBlinkInterval = 0.55f;

		private static GameObject? _panel;

		private static Text? _statusText;

		private static Button? _showHiddenButton;

		private static Button? _withdrawButton;

		private static Text? _withdrawButtonText;

		private static Text? _withdrawAlertText;

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

		private static readonly List<StoreRowWidgets> RowWidgets = new List<StoreRowWidgets>();

		private static readonly Dictionary<string, Sprite?> SnapshotCache = new Dictionary<string, Sprite>();

		private static readonly Dictionary<string, string> ListingIconBase64Cache = new Dictionary<string, string>(StringComparer.Ordinal);

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

		private static readonly HashSet<string> RequestedListingIconIds = new HashSet<string>(StringComparer.Ordinal);

		private static readonly Queue<SnapshotDecodeRequest> PendingSnapshotDecodes = new Queue<SnapshotDecodeRequest>();

		private static readonly HashSet<string> PendingSnapshotDecodeKeys = new HashSet<string>(StringComparer.Ordinal);

		private static readonly HashSet<string> HiddenListingIds = new HashSet<string>(StringComparer.Ordinal);

		private static Sprite? _missingSnapshot;

		private static Sprite? _missingPriceIcon;

		private static List<ZoneBlueprintStoreListingSummaryDto> _listings = new List<ZoneBlueprintStoreListingSummaryDto>();

		private static List<ZoneBlueprintStoreListingSummaryDto> _visibleListings = new List<ZoneBlueprintStoreListingSummaryDto>();

		private static int _scrollOffset;

		private static int _totalListings;

		private static int _hiddenListingCount;

		private static int _latestListRequestId;

		private static bool _showHidden;

		private static bool _hasWithdrawableBalance;

		private static bool _withdrawBlinkOn = true;

		private static bool _hiddenStateLoaded;

		private static bool _hiddenStateDirty;

		private static bool _inputBlocked;

		private static float _nextWithdrawBlinkAt;

		private static string _loadedHiddenListingsPath = "";

		private static string HiddenListingsPath => Path.Combine(HomesteadPlugin.DataStorageFullPath, GetHiddenListingsFileName());

		public static bool Open()
		{
			if (IsPanelVisible())
			{
				ApplyPanelLayout();
				SetInputBlocked(blocked: true);
				return false;
			}
			EnsurePanel();
			if ((Object)(object)_panel != (Object)null)
			{
				LoadHiddenState();
				_scrollOffset = 0;
				ApplyPanelLayout();
				ClearListingRowsForLoading();
				_panel.SetActive(true);
				SetStatus(HomesteadLocalization.Text("hs_store_loading"));
				SetInputBlocked(blocked: true);
				return true;
			}
			return false;
		}

		public static void ResetForWorldSession()
		{
			_listings = new List<ZoneBlueprintStoreListingSummaryDto>();
			_visibleListings = new List<ZoneBlueprintStoreListingSummaryDto>();
			_scrollOffset = 0;
			_totalListings = 0;
			_hiddenListingCount = 0;
			_latestListRequestId = 0;
			_showHidden = false;
			_hasWithdrawableBalance = false;
			_withdrawBlinkOn = true;
			_hiddenStateLoaded = false;
			_hiddenStateDirty = false;
			_nextWithdrawBlinkAt = 0f;
			_loadedHiddenListingsPath = "";
			HiddenListingIds.Clear();
			RequestedListingIconIds.Clear();
			ClearSnapshotDecodeQueue();
			if ((Object)(object)_panel != (Object)null && Object.op_Implicit((Object)(object)_panel))
			{
				_panel.SetActive(false);
			}
			SetInputBlocked(blocked: false);
		}

		public static void Update()
		{
			if (IsPanelVisible())
			{
				ApplyPanelLayout();
			}
			if (_inputBlocked && !IsPanelVisible())
			{
				SetInputBlocked(blocked: false);
			}
			if (IsPanelVisible() && Input.GetKeyDown((KeyCode)27))
			{
				Close();
			}
			if (IsPanelVisible())
			{
				HandleScrollInput();
				ProcessSnapshotDecodeQueue();
				UpdateWithdrawBlink();
			}
		}

		public static void SetListings(ZoneBlueprintStoreListResponse response)
		{
			if (response.RequestId <= 0 || response.RequestId == _latestListRequestId)
			{
				List<ZoneBlueprintStoreListingSummaryDto> list = response.Listings ?? new List<ZoneBlueprintStoreListingSummaryDto>();
				MergeListingIconCache(response.Icons ?? new List<ZoneBlueprintStoreListingIconDto>());
				_listings = list;
				_visibleListings = list;
				_scrollOffset = response.Offset;
				_totalListings = response.TotalListings;
				_hiddenListingCount = response.HiddenListings;
				_hasWithdrawableBalance = response.HasWithdrawableBalance;
				_withdrawBlinkOn = true;
				_nextWithdrawBlinkAt = 0f;
				ClearSnapshotDecodeQueue();
				EnsurePanel();
				LogStoreListingDebug(response, list);
				RefreshRows();
				RefreshWithdrawButton(force: true);
				RequestMissingVisibleListingIcons();
				SetStatus(string.IsNullOrWhiteSpace(response.Message) ? BuildListingStatusText() : response.Message);
			}
		}

		public static void SetWithdrawableBalance(bool hasBalance)
		{
			_hasWithdrawableBalance = hasBalance;
			_withdrawBlinkOn = true;
			_nextWithdrawBlinkAt = 0f;
			RefreshWithdrawButton(force: true);
		}

		public static void ApplyListingIcons(ZoneBlueprintStoreListResponse response)
		{
			MergeListingIconCache(response.Icons ?? new List<ZoneBlueprintStoreListingIconDto>());
			if (IsPanelVisible())
			{
				RefreshRows();
				RequestMissingVisibleListingIcons();
			}
		}

		public static bool TryApplyListingPatch(ZoneBlueprintStoreStatusResponse response)
		{
			ZoneBlueprintStoreStatusResponse response2 = response;
			if (!response2.Success || string.IsNullOrWhiteSpace(response2.ListingId) || _listings.Count == 0)
			{
				return false;
			}
			int num = _listings.FindIndex((ZoneBlueprintStoreListingSummaryDto listing) => string.Equals(listing.ListingId, response2.ListingId, StringComparison.Ordinal));
			if (num < 0)
			{
				return false;
			}
			if (response2.RemoveListing)
			{
				_listings.RemoveAt(num);
				_totalListings = Math.Max(0, _totalListings - 1);
			}
			else
			{
				if (response2.Listing == null)
				{
					return false;
				}
				_listings[num] = response2.Listing;
			}
			_visibleListings = _listings;
			RefreshRows();
			RequestMissingVisibleListingIcons();
			return true;
		}

		private static void LogStoreListingDebug(ZoneBlueprintStoreListResponse response, IReadOnlyList<ZoneBlueprintStoreListingSummaryDto> listings)
		{
			if (BlueprintConfig.StoreDebugLogging)
			{
				Player localPlayer = Player.m_localPlayer;
				long num = (((Object)(object)localPlayer != (Object)null) ? localPlayer.GetPlayerID() : 0);
				string text = (string.IsNullOrWhiteSpace(_loadedHiddenListingsPath) ? "(not loaded)" : Path.GetFileName(_loadedHiddenListingsPath));
				HomesteadPlugin.HomesteadLogger.LogInfo((object)$"Blueprint Store debug: mode={BlueprintConfig.StoreIdentityMode}, localPlayerId={num}, requestId={response.RequestId}, offset={response.Offset}, received={listings.Count}, total={response.TotalListings}, serverHidden={response.HiddenListings}, clientHidden={HiddenListingIds.Count}, showHidden={_showHidden}, hiddenFile={text}");
				int num2 = Mathf.Min(listings.Count, 50);
				for (int i = 0; i < num2; i++)
				{
					ZoneBlueprintStoreListingSummaryDto zoneBlueprintStoreListingSummaryDto = listings[i];
					bool flag = HiddenListingIds.Contains(zoneBlueprintStoreListingSummaryDto.ListingId);
					ZoneBlueprintStoreListingIdentityDebugDto debugIdentity = zoneBlueprintStoreListingSummaryDto.DebugIdentity;
					HomesteadPlugin.HomesteadLogger.LogInfo((object)string.Format("Blueprint Store debug listing[{0}]: id={1}, name=\"{2}\", seller=\"{3}\", sellerPlayerId={4}, requesterPlayerId={5}, dtoMode={6}, canManage={7}, canDelist={8}, hidden={9}, offers={10}, purchases={11}", i, zoneBlueprintStoreListingSummaryDto.ListingId, DebugText(zoneBlueprintStoreListingSummaryDto.Name), DebugText(zoneBlueprintStoreListingSummaryDto.SellerName), debugIdentity?.SellerPlayerId.ToString() ?? "n/a", debugIdentity?.RequesterPlayerId.ToString() ?? "n/a", debugIdentity?.IdentityMode ?? "n/a", zoneBlueprintStoreListingSummaryDto.CanManage, zoneBlueprintStoreListingSummaryDto.CanDelist, flag, zoneBlueprintStoreListingSummaryDto.OfferCount, zoneBlueprintStoreListingSummaryDto.PurchaseCount));
				}
				if (listings.Count > num2)
				{
					HomesteadPlugin.HomesteadLogger.LogInfo((object)$"Blueprint Store debug: skipped {listings.Count - num2} additional listings.");
				}
			}
		}

		private static string DebugText(string value)
		{
			return (value ?? "").Replace("\r", " ").Replace("\n", " ").Trim();
		}

		public static void RequestCurrentPage(IReadOnlyList<string>? iconListingIds = null, bool includeNotifications = false)
		{
			LoadHiddenState();
			SyncHiddenStateIfNeeded();
			ZoneBlueprintStore.RequestListingPage(NextListRequestId(), _scrollOffset, iconListingIds, _showHidden, includeNotifications);
		}

		private static void RequestPage(int offset, IReadOnlyList<string>? iconListingIds = null)
		{
			LoadHiddenState();
			SyncHiddenStateIfNeeded();
			_scrollOffset = Mathf.Max(0, offset);
			SetStatus(HomesteadLocalization.Text("hs_store_loading"));
			ZoneBlueprintStore.RequestListingPage(NextListRequestId(), _scrollOffset, iconListingIds, _showHidden, includeNotifications: false);
		}

		private static int NextListRequestId()
		{
			_latestListRequestId++;
			if (_latestListRequestId <= 0)
			{
				_latestListRequestId = 1;
			}
			return _latestListRequestId;
		}

		private static void SyncHiddenStateIfNeeded()
		{
			if (_hiddenStateDirty)
			{
				_hiddenStateDirty = false;
				ZoneBlueprintStore.SyncHiddenListings(HiddenListingIds);
			}
		}

		private static void MergeListingIconCache(IEnumerable<ZoneBlueprintStoreListingIconDto> icons)
		{
			foreach (ZoneBlueprintStoreListingIconDto icon in icons)
			{
				if (icon != null && !string.IsNullOrWhiteSpace(icon.ListingId) && !string.IsNullOrWhiteSpace(icon.IconPngBase64))
				{
					ListingIconBase64Cache[icon.ListingId] = icon.IconPngBase64;
				}
			}
		}

		private static void EnsurePanel()
		{
			//IL_005d: 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_007b: 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_008f: 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_00ca: 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_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Expected O, but got Unknown
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Expected O, but got Unknown
			//IL_01d4: 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_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: 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_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cd: 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_02eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b2: Expected O, but got Unknown
			//IL_033a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0349: Unknown result type (might be due to invalid IL or missing references)
			//IL_0358: Unknown result type (might be due to invalid IL or missing references)
			//IL_0366: Unknown result type (might be due to invalid IL or missing references)
			//IL_036c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a1: 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_03bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_040e: Unknown result type (might be due to invalid IL or missing references)
			//IL_041d: Unknown result type (might be due to invalid IL or missing references)
			//IL_042b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0431: Unknown result type (might be due to invalid IL or missing references)
			//IL_045d: Unknown result type (might be due to invalid IL or missing references)
			//IL_046c: Unknown result type (might be due to invalid IL or missing references)
			//IL_047b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0489: Unknown result type (might be due to invalid IL or missing references)
			//IL_048f: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: Unknown result type (might be due to invalid IL or missing references)
			//IL_031e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0324: Expected O, but got Unknown
			//IL_0520: Unknown result type (might be due to invalid IL or missing references)
			//IL_0527: Expected O, but got Unknown
			//IL_0547: Unknown result type (might be due to invalid IL or missing references)
			//IL_055c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0571: Unknown result type (might be due to invalid IL or missing references)
			//IL_058f: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_05cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_060e: Unknown result type (might be due to invalid IL or missing references)
			//IL_061d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0644: Unknown result type (might be due to invalid IL or missing references)
			//IL_0653: Unknown result type (might be due to invalid IL or missing references)
			//IL_0662: Unknown result type (might be due to invalid IL or missing references)
			//IL_0670: Unknown result type (might be due to invalid IL or missing references)
			//IL_0676: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_06bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_06cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_06df: Unknown result type (might be due to invalid IL or missing references)
			//IL_0716: Unknown result type (might be due to invalid IL or missing references)
			//IL_0725: Unknown result type (might be due to invalid IL or missing references)
			//IL_0734: Unknown result type (might be due to invalid IL or missing references)
			//IL_0742: Unknown result type (might be due to invalid IL or missing references)
			//IL_0748: Unknown result type (might be due to invalid IL or missing references)
			//IL_0787: Unknown result type (might be due to invalid IL or missing references)
			//IL_0796: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_07dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e7: Expected O, but got Unknown
			//IL_0805: Unknown result type (might be due to invalid IL or missing references)
			//IL_0814: Unknown result type (might be due to invalid IL or missing references)
			//IL_0823: Unknown result type (might be due to invalid IL or missing references)
			//IL_0854: Unknown result type (might be due to invalid IL or missing references)
			//IL_085e: Expected O, but got Unknown
			//IL_087c: Unknown result type (might be due to invalid IL or missing references)
			//IL_088b: Unknown result type (might be due to invalid IL or missing references)
			//IL_089a: Unknown result type (might be due to invalid IL or missing references)
			//IL_08cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_08d5: Expected O, but got Unknown
			//IL_08f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0902: Unknown result type (might be due to invalid IL or missing references)
			//IL_0911: Unknown result type (might be due to invalid IL or missing references)
			//IL_0942: Unknown result type (might be due to invalid IL or missing references)
			//IL_094c: Expected O, but got Unknown
			//IL_0965: Unknown result type (might be due to invalid IL or missing references)
			//IL_0974: Unknown result type (might be due to invalid IL or missing references)
			//IL_0983: Unknown result type (might be due to invalid IL or missing references)
			//IL_09b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_09be: Expected O, but got Unknown
			//IL_09d1: Unknown result type (might be due to invalid IL or missing references)
			if (HasUsablePanel() || (Object)(object)GUIManager.CustomGUIFront == (Object)null)
			{
				return;
			}
			ResetPanel();
			GUIManager instance = GUIManager.Instance;
			_panel = ZoneBlueprintStorePanelLayout.CreatePanel(instance, GUIManager.CustomGUIFront.transform, ZoneBlueprintStorePanelKind.Large, "HomesteadBlueprintStorePanel");
			Transform transform = _panel.transform;
			instance.CreateText(HomesteadLocalization.Text("hs_store_title"), transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -28f), instance.AveriaSerifBold, 22, instance.ValheimOrange, true, Color.black, 620f, 30f, false);
			ButtonClickedEvent onClick = instance.CreateButton(HomesteadLocalization.Text("hs_common_refresh"), transform, new Vector2(0f, 1f), new Vector2(0f, 1f), new Vector2(82f, -548f), 128f, 34f).GetComponent<Button>().onClick;
			object obj = <>O.<0>__RequestListings;
			if (obj == null)
			{
				UnityAction val = ZoneBlueprintStore.RequestListings;
				<>O.<0>__RequestListings = val;
				obj = (object)val;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			_withdrawButton = instance.CreateButton(HomesteadLocalization.Text("hs_common_withdraw"), transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -548f), 128f, 34f).GetComponent<Button>();
			ButtonClickedEvent onClick2 = _withdrawButton.onClick;
			object obj2 = <>O.<1>__RequestWithdraw;
			if (obj2 == null)
			{
				UnityAction val2 = ZoneBlueprintStore.RequestWithdraw;
				<>O.<1>__RequestWithdraw = val2;
				obj2 = (object)val2;
			}
			((UnityEvent)onClick2).AddListener((UnityAction)obj2);
			_withdrawButtonText = ((Component)_withdrawButton).GetComponentInChildren<Text>();
			if ((Object)(object)_withdrawButtonText != (Object)null)
			{
				_withdrawButtonText.supportRichText = false;
			}
			_withdrawAlertText = instance.CreateText("!", ((Component)_withdrawButton).transform, new Vector2(1f, 0.5f), new Vector2(1f, 0.5f), new Vector2(-10f, 0f), instance.AveriaSerifBold, 20, instance.ValheimYellow, true, Color.black, 20f, 24f, false).GetComponent<Text>();
			((Component)_withdrawAlertText).gameObject.SetActive(false);
			RefreshWithdrawButton(force: true);
			_showHiddenButton = instance.CreateButton(HomesteadLocalization.Text("hs_store_show_hidden"), transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(158f, -548f), 116f, 34f).GetComponent<Button>();
			ButtonClickedEvent onClick3 = _showHiddenButton.onClick;
			object obj3 = <>O.<2>__ToggleShowHidden;
			if (obj3 == null)
			{
				UnityAction val3 = ToggleShowHidden;
				<>O.<2>__ToggleShowHidden = val3;
				obj3 = (object)val3;
			}
			((UnityEvent)onClick3).AddListener((UnityAction)obj3);
			ButtonClickedEvent onClick4 = instance.CreateButton(HomesteadLocalization.Text("hs_common_close"), transform, new Vector2(1f, 1f), new Vector2(1f, 1f), new Vector2(-82f, -548f), 128f, 34f).GetComponent<Button>().onClick;
			object obj4 = <>O.<3>__Close;
			if (obj4 == null)
			{
				UnityAction val4 = Close;
				<>O.<3>__Close = val4;
				obj4 = (object)val4;
			}
			((UnityEvent)onClick4).AddListener((UnityAction)obj4);
			_statusText = instance.CreateText("", transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -506f), instance.AveriaSerif, 14, instance.ValheimYellow, true, Color.black, 620f, 28f, false).GetComponent<Text>();
			instance.CreateText(HomesteadLocalization.Text("hs_store_col_blueprint"), transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(-332f, -58f), instance.AveriaSerifBold, 13, instance.ValheimOrange, true, Color.black, 140f, 20f, false);
			instance.CreateText(HomesteadLocalization.Text("hs_store_col_price"), transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(-178f, -58f), instance.AveriaSerifBold, 13, instance.ValheimOrange, true, Color.black, 140f, 20f, false);
			instance.CreateText(HomesteadLocalization.Text("hs_store_col_creator"), transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(-18f, -58f), instance.AveriaSerifBold, 13, instance.ValheimOrange, true, Color.black, 90f, 20f, false);
			instance.CreateText(HomesteadLocalization.Text("hs_store_col_bought"), transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(72f, -58f), instance.AveriaSerifBold, 13, instance.ValheimOrange, true, Color.black, 70f, 20f, false);
			for (int i = 0; i < 6; i++)
			{
				GameObject val5 = new GameObject($"StoreRow{i}");
				val5.transform.SetParent(transform, false);
				RectTransform obj5 = val5.AddComponent<RectTransform>();
				obj5.anchorMin = new Vector2(0.5f, 1f);
				obj5.anchorMax = new Vector2(0.5f, 1f);
				obj5.pivot = new Vector2(0.5f, 1f);
				obj5.anchoredPosition = new Vector2(0f, -82f - (float)i * 70f);
				obj5.sizeDelta = new Vector2(840f, 64f);
				((Graphic)val5.AddComponent<Image>()).color = ((i % 2 == 0) ? new Color(0.05f, 0.045f, 0.035f, 0.32f) : new Color(0.02f, 0.018f, 0.014f, 0.22f));
				StoreRowWidgets storeRowWidgets = new StoreRowWidgets
				{
					Snapshot = CreateImage(val5.transform, "Snapshot", new Vector2(-382f, -32f), new Vector2(54f, 54f)),
					Name = instance.CreateText("", val5.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(-312f, -18f), instance.AveriaSerifBold, 14, instance.ValheimBeige, true, Color.black, 128f, 20f, false).GetComponent<Text>(),
					Seller = instance.CreateText("", val5.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(-18f, -32f), instance.AveriaSerif, 13, instance.ValheimBeige, true, Color.black, 82f, 24f, false).GetComponent<Text>(),
					Purchases = instance.CreateText("", val5.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(72f, -32f), instance.AveriaSerifBold, 14, instance.ValheimYellow, true, Color.black, 48f, 24f, false).GetComponent<Text>()
				};
				storeRowWidgets.Button = instance.CreateButton(HomesteadLocalization.Text("hs_common_buy"), val5.transform, new Vector2(1f, 0.5f), new Vector2(1f, 0.5f), new Vector2(-205f, 0f), 52f, 32f).GetComponent<Button>();
				int index = i;
				((UnityEvent)storeRowWidgets.Button.onClick).AddListener((UnityAction)delegate
				{
					PrimaryAction(index);
				});
				storeRowWidgets.OfferButton = instance.CreateButton(HomesteadLocalization.Text("hs_common_offer"), val5.transform, new Vector2(1f, 0.5f), new Vector2(1f, 0.5f), new Vector2(-147f, 0f), 58f, 32f).GetComponent<Button>();
				((UnityEvent)storeRowWidgets.OfferButton.onClick).AddListener((UnityAction)delegate
				{
					OpenOfferInput(index);
				});
				storeRowWidgets.OffersButton = instance.CreateButton(HomesteadLocalization.Text("hs_common_offers"), val5.transform, new Vector2(1f, 0.5f), new Vector2(1f, 0.5f), new Vector2(-86f, 0f), 62f, 32f).GetComponent<Button>();
				((UnityEvent)storeRowWidgets.OffersButton.onClick).AddListener((UnityAction)delegate
				{
					OpenOfferList(index);
				});
				storeRowWidgets.HideButton = instance.CreateButton(HomesteadLocalization.Text("hs_common_hide"), val5.transform, new Vector2(1f, 0.5f), new Vector2(1f, 0.5f), new Vector2(-35f, 0f), 46f, 32f).GetComponent<Button>();
				((UnityEvent)storeRowWidgets.HideButton.onClick).AddListener((UnityAction)delegate
				{
					ToggleHidden(index);
				});
				storeRowWidgets.DelistButton = instance.CreateButton("X", val5.transform, new Vector2(1f, 0.5f), new Vector2(1f, 0.5f), new Vector2(-8f, 0f), 24f, 32f).GetComponent<Button>();
				((UnityEvent)storeRowWidgets.DelistButton.onClick).AddListener((UnityAction)delegate
				{
					Delist(index);
				});
				ZoneBlueprintStorePriceIconStrip.CreateSlots(instance, val5.transform, 8, new Vector2(-232f, -20f), 34f, -26f, 4, storeRowWidgets.PriceIcons, storeRowWidgets.PriceAmounts);
				RowWidgets.Add(storeRowWidgets);
				Rows.Add(val5);
			}
			RefreshRows();
		}

		private static bool HasUsablePanel()
		{
			if ((Object)(object)_panel != (Object)null && Object.op_Implicit((Object)(object)_panel) && Rows.Count == 6 && RowWidgets.Count == 6)
			{
				return Rows.All((GameObject row) => (Object)(object)row != (Object)null && Object.op_Implicit((Object)(object)row));
			}
			return false;
		}

		private static void ResetPanel()
		{
			SetInputBlocked(blocked: false);
			if ((Object)(object)_panel != (Object)null && Object.op_Implicit((Object)(object)_panel))
			{
				Object.Destroy((Object)(object)_panel);
			}
			_panel = null;
			_statusText = null;
			_withdrawButton = null;
			_withdrawButtonText = null;
			_withdrawAlertText = null;
			_showHiddenButton = null;
			Rows.Clear();
			RowWidgets.Clear();
		}

		private static void ApplyPanelLayout()
		{
			ZoneBlueprintStorePanelLayout.Apply(_panel, ZoneBlueprintStorePanelKind.Large);
		}

		private static void RefreshRows()
		{
			ClampScrollOffset();
			RefreshShowHiddenButton();
			RefreshWithdrawButton(force: false);
			for (int i = 0; i < Rows.Count; i++)
			{
				GameObject val = Rows[i];
				if (!((Object)(object)val == (Object)null) && Object.op_Implicit((Object)(object)val))
				{
					int num = i;
					bool flag = num < _visibleListings.Count;
					val.SetActive(flag);
					if (flag)
					{
						ZoneBlueprintStoreListingSummaryDto listing = _visibleListings[num];
						RefreshRow(RowWidgets[i], listing);
					}
				}
			}
			SetStatus(BuildListingStatusText());
		}

		private static void ClearListingRowsForLoading()
		{
			_listings = new List<ZoneBlueprintStoreListingSummaryDto>();
			_visibleListings = new List<ZoneBlueprintStoreListingSummaryDto>();
			_totalListings = 0;
			_hiddenListingCount = 0;
			_scrollOffset = 0;
			RefreshShowHiddenButton();
			foreach (GameObject row in Rows)
			{
				if ((Object)(object)row != (Object)null && Object.op_Implicit((Object)(object)row))
				{
					row.SetActive(false);
				}
			}
		}

		private static void RefreshRow(StoreRowWidgets widgets, ZoneBlueprintStoreListingSummaryDto listing)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)widgets.Snapshot != (Object)null)
			{
				widgets.Snapshot.sprite = GetSnapshotSpriteLazy(listing);
				((Graphic)widgets.Snapshot).color = Color.white;
				widgets.Snapshot.preserveAspect = true;
			}
			if ((Object)(object)widgets.Name != (Object)null)
			{
				widgets.Name.text = listing.Name;
			}
			if ((Object)(object)widgets.Seller != (Object)null)
			{
				widgets.Seller.text = listing.SellerName;
			}
			if ((Object)(object)widgets.Purchases != (Object)null)
			{
				widgets.Purchases.text = listing.PurchaseCount.ToString();
			}
			if ((Object)(object)widgets.HideButton != (Object)null)
			{
				bool flag = HiddenListingIds.Contains(listing.ListingId);
				Text componentInChildren = ((Component)widgets.HideButton).GetComponentInChildren<Text>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					componentInChildren.text = (flag ? HomesteadLocalization.Text("hs_common_show") : HomesteadLocalization.Text("hs_common_hide"));
				}
			}
			if ((Object)(object)widgets.DelistButton != (Object)null)
			{
				((Component)widgets.DelistButton).gameObject.SetActive(listing.CanDelist);
			}
			if ((Object)(object)widgets.Button != (Object)null)
			{
				Text componentInChildren2 = ((Component)widgets.Button).GetComponentInChildren<Text>();
				if ((Object)(object)componentInChildren2 != (Object)null)
				{
					componentInChildren2.text = (listing.CanManage ? HomesteadLocalization.Text("hs_common_edit") : HomesteadLocalization.Text("hs_common_buy"));
				}
			}
			if ((Object)(object)widgets.OfferButton != (Object)null)
			{
				((Component)widgets.OfferButton).gameObject.SetActive(!listing.CanManage);
			}
			if ((Object)(object)widgets.OffersButton != (Object)null)
			{
				Text componentInChildren3 = ((Component)widgets.OffersButton).GetComponentInChildren<Text>();
				if ((Object)(object)componentInChildren3 != (Object)null)
				{
					componentInChildren3.text = ((listing.OfferCount > 0) ? HomesteadLocalization.Format("hs_store_offers_count", listing.OfferCount) : HomesteadLocalization.Text("hs_common_offers"));
				}
			}
			LayoutActionButtons(widgets, listing);
			ZoneBlueprintStorePriceIconStrip.Refresh(listing.PriceItems, 8, widgets.PriceIcons, widgets.PriceAmounts);
		}

		private static void LayoutActionButtons(StoreRowWidgets widgets, ZoneBlueprintStoreListingSummaryDto listing)
		{
			//IL_0112: 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)
			List<(Button, float)> list = new List<(Button, float)>();
			if ((Object)(object)widgets.DelistButton != (Object)null && listing.CanDelist)
			{
				list.Add((widgets.DelistButton, 28f));
			}
			list.Add((widgets.HideButton, 48f));
			list.Add((widgets.OffersButton, (listing.OfferCount > 0) ? 82f : 68f));
			if (!listing.CanManage)
			{
				list.Add((widgets.OfferButton, 58f));
			}
			list.Add((widgets.Button, listing.CanManage ? 58f : 52f));
			float num = -10f;
			foreach (var (val, num2) in list)
			{
				if (!((Object)(object)val == (Object)null) && Object.op_Implicit((Object)(object)val))
				{
					((Component)val).gameObject.SetActive(true);
					RectTransform component = ((Component)val).GetComponent<RectTransform>();
					component.SetSizeWithCurrentAnchors((Axis)0, num2);
					component.anchoredPosition = new Vector2(num - num2 * 0.5f, component.anchoredPosition.y);
					num -= num2 + 6f;
				}
			}
		}

		private static void HandleScrollInput()
		{
			if (_totalListings <= 6)
			{
				return;
			}
			float axis = Input.GetAxis("Mouse ScrollWheel");
			if (!(Mathf.Abs(axis) < 0.05f))
			{
				int num = ((axis < 0f) ? 6 : (-6));
				int maxPageOffset = GetMaxPageOffset();
				int num2 = Mathf.Clamp(_scrollOffset + num, 0, maxPageOffset);
				if (num2 != _scrollOffset)
				{
					RequestPage(num2);
				}
			}
		}

		private static void RequestMissingVisibleListingIcons()
		{
			if (_visibleListings.Count == 0)
			{
				return;
			}
			List<string> list = new List<string>();
			int num = Mathf.Min(6, _visibleListings.Count);
			for (int i = 0; i < num; i++)
			{
				ZoneBlueprintStoreListingSummaryDto zoneBlueprintStoreListingSummaryDto = _visibleListings[i];
				if (zoneBlueprintStoreListingSummaryDto != null && !string.IsNullOrWhiteSpace(zoneBlueprintStoreListingSummaryDto.ListingId) && !ListingIconBase64Cache.ContainsKey(zoneBlueprintStoreListingSummaryDto.ListingId) && !RequestedListingIconIds.Contains(zoneBlueprintStoreListingSummaryDto.ListingId))
				{
					RequestedListingIconIds.Add(zoneBlueprintStoreListingSummaryDto.ListingId);
					list.Add(zoneBlueprintStoreListingSummaryDto.ListingId);
				}
			}
			if (list.Count > 0)
			{
				ZoneBlueprintStore.RequestListingIcons(list);
			}
		}

		private static void ToggleHidden(int rowIndex)
		{
			if (rowIndex >= 0 && rowIndex < _visibleListings.Count)
			{
				string listingId = _visibleListings[rowIndex].ListingId;
				if (!HiddenListingIds.Remove(listingId))
				{
					HiddenListingIds.Add(listingId);
				}
				SaveHiddenState();
				_hiddenStateDirty = true;
				RequestPage(_scrollOffset);
			}
		}

		private static void ToggleShowHidden()
		{
			_showHidden = !_showHidden;
			RequestPage(0);
		}

		private static void ClampScrollOffset()
		{
			_scrollOffset = Mathf.Clamp(_scrollOffset, 0, GetMaxPageOffset());
		}

		private static int GetMaxPageOffset()
		{
			if (_totalListings <= 0)
			{
				return 0;
			}
			return (_totalListings - 1) / 6 * 6;
		}

		private static void RefreshShowHiddenButton()
		{
			if (!((Object)(object)_showHiddenButton == (Object)null) && Object.op_Implicit((Object)(object)_showHiddenButton))
			{
				Text componentInChildren = ((Component)_showHiddenButton).GetComponentInChildren<Text>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					componentInChildren.text = (_showHidden ? HomesteadLocalization.Text("hs_store_hide_hidden") : HomesteadLocalization.Text("hs_store_show_hidden"));
				}
			}
		}

		private static void UpdateWithdrawBlink()
		{
			if (_hasWithdrawableBalance && !(Time.unscaledTime < _nextWithdrawBlinkAt))
			{
				_nextWithdrawBlinkAt = Time.unscaledTime + 0.55f;
				_withdrawBlinkOn = !_withdrawBlinkOn;
				RefreshWithdrawButton(force: true);
			}
		}

		private static void RefreshWithdrawButton(bool force)
		{
			if ((Object)(object)_withdrawButtonText != (Object)null && Object.op_Implicit((Object)(object)_withdrawButtonText))
			{
				string text = HomesteadLocalization.Text("hs_common_withdraw");
				if (force || !string.Equals(_withdrawButtonText.text, text, StringComparison.Ordinal))
				{
					_withdrawButtonText.text = text;
				}
			}
			if (!((Object)(object)_withdrawAlertText == (Object)null) && Object.op_Implicit((Object)(object)_withdrawAlertText))
			{
				bool flag = _hasWithdrawableBalance && _withdrawBlinkOn;
				if (force || ((Component)_withdrawAlertText).gameObject.activeSelf != flag)
				{
					((Component)_withdrawAlertText).gameObject.SetActive(flag);
				}
			}
		}

		private static string BuildListingStatusText()
		{
			int hiddenListingCount = _hiddenListingCount;
			if (_visibleListings.Count == 0)
			{
				if (hiddenListingCount <= 0 || _showHidden)
				{
					return HomesteadLocalization.Text("hs_store_no_listings");
				}
				return HomesteadLocalization.Format("hs_store_no_visible_listings", hiddenListingCount);
			}
			int num = _scrollOffset + 1;
			int num2 = Mathf.Min(_scrollOffset + _visibleListings.Count, _totalListings);
			string text = ((hiddenListingCount > 0) ? HomesteadLocalization.Format("hs_store_hidden_count", hiddenListingCount) : "");
			string text2 = (_showHidden ? HomesteadLocalization.Text("hs_store_showing_hidden") : "");
			return HomesteadLocalization.Format("hs_store_listing_status", num, num2, _totalListings, text, text2);
		}

		private static void LoadHiddenState()
		{
			string hiddenListingsPath = HiddenListingsPath;
			if (_hiddenStateLoaded && string.Equals(_loadedHiddenListingsPath, hiddenListingsPath, StringComparison.Ordinal))
			{
				return;
			}
			_hiddenStateLoaded = true;
			_loadedHiddenListingsPath = hiddenListingsPath;
			HiddenListingIds.Clear();
			try
			{
				if (!File.Exists(hiddenListingsPath))
				{
					return;
				}
				string[] array = File.ReadAllLines(hiddenListingsPath);
				for (int i = 0; i < array.Length; i++)
				{
					string text = array[i].Trim();
					if (!string.IsNullOrWhiteSpace(text))
					{
						HiddenListingIds.Add(text);
					}
				}
			}
			catch
			{
				HiddenListingIds.Clear();
			}
			_hiddenStateDirty = true;
		}

		private static void SaveHiddenState()
		{
			try
			{
				string hiddenListingsPath = HiddenListingsPath;
				Directory.CreateDirectory(Path.GetDirectoryName(hiddenListingsPath));
				File.WriteAllLines(hiddenListingsPath, HiddenListingIds.OrderBy<string, string>((string id) => id, StringComparer.Ordinal));
			}
			catch
			{
			}
		}

		private static string GetHiddenListingsFileName()
		{
			long num = (((Object)(object)Player.m_localPlayer != (Object)null) ? Player.m_localPlayer.GetPlayerID() : 0);
			if (BlueprintConfig.StoreIdentityMode == BlueprintStoreIdentityMode.PlayerId && num != 0L)
			{
				return $"BlueprintStore.hidden.player_{num}.txt";
			}
			if (BlueprintConfig.StoreIdentityMode == BlueprintStoreIdentityMode.SteamId)
			{
				string value = ((num != 0L) ? HomesteadPlayerIdentity.ResolveLocalPlatformId(num) : "");
				value = HomesteadPlayerIdentity.NormalizePlatformId(value);
				if (!string.IsNullOrWhiteSpace(value))
				{
					return "BlueprintStore.hidden." + SanitizeFileToken(value) + ".txt";
				}
			}
			return "BlueprintStore.hidden.txt";
		}

		private static string SanitizeFileToken(string value)
		{
			char[] invalid = Path.GetInvalidFileNameChars();
			string text = new string(value.Select((char ch) => (!invalid.Contains(ch)) ? ch : '_').ToArray());
			if (!string.IsNullOrWhiteSpace(text))
			{
				return text;
			}
			return "unknown";
		}

		private static Image CreateImage(Transform parent, string name, Vector2 anchoredPosition, Vector2 size)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: 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_0031: 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_0046: 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_005b: 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_0070: 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_0077: 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)
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			RectTransform val2 = (RectTransform)val.transform;
			val2.anchorMin = new Vector2(0.5f, 1f);
			val2.anchorMax = new Vector2(0.5f, 1f);
			val2.pivot = new Vector2(0.5f, 0.5f);
			val2.anchoredPosition = anchoredPosition;
			val2.sizeDelta = size;
			Image obj = val.AddComponent<Image>();
			((Graphic)obj).color = Color.white;
			obj.preserveAspect = true;
			return obj;
		}

		private static Sprite GetSnapshotSpriteLazy(ZoneBlueprintStoreListingSummaryDto listing)
		{
			string key = SnapshotKey(listing);
			if (SnapshotCache.TryGetValue(key, out Sprite value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			QueueSnapshotDecode(key, listing);
			return GetMissingSnapshotSprite();
		}

		private static string SnapshotKey(ZoneBlueprintStoreListingSummaryDto listing)
		{
			ListingIconBase64Cache.TryGetValue(listing.ListingId, out string value);
			return listing.ListingId + ":" + (value ?? "").GetHashCode();
		}

		private static void QueueSnapshotDecode(string key, ZoneBlueprintStoreListingSummaryDto listing)
		{
			if (!SnapshotCache.ContainsKey(key) && !PendingSnapshotDecodeKeys.Contains(key))
			{
				ListingIconBase64Cache.TryGetValue(listing.ListingId, out string value);
				PendingSnapshotDecodeKeys.Add(key);
				PendingSnapshotDecodes.Enqueue(new SnapshotDecodeRequest(key, listing.ListingId, listing.Name, value ?? ""));
			}
		}

		private static void ProcessSnapshotDecodeQueue()
		{
			if (PendingSnapshotDecodes.Count == 0)
			{
				return;
			}
			SnapshotDecodeRequest snapshotDecodeRequest = PendingSnapshotDecodes.Dequeue();
			PendingSnapshotDecodeKeys.Remove(snapshotDecodeRequest.Key);
			if (SnapshotCache.TryGetValue(snapshotDecodeRequest.Key, out Sprite value) && (Object)(object)value != (Object)null)
			{
				ApplySnapshotSprite(snapshotDecodeRequest.Key, value);
				return;
			}
			Sprite val = ZoneBlueprintVisuals.CreateIconFromBase64(snapshotDecodeRequest.ListingId, snapshotDecodeRequest.IconPngBase64);
			if ((Object)(object)val == (Object)null && ZoneBlueprintVisuals.TryGetIcon(snapshotDecodeRequest.Name, out Sprite icon))
			{
				val = icon;
			}
			if (val == null)
			{
				val = GetMissingSnapshotSprite();
			}
			SnapshotCache[snapshotDecodeRequest.Key] = val;
			ApplySnapshotSprite(snapshotDecodeRequest.Key, val);
		}

		private static void ApplySnapshotSprite(string key, Sprite sprite)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < RowWidgets.Count; i++)
			{
				int num = i;
				if (num >= 0 && num < _visibleListings.Count && string.Equals(SnapshotKey(_visibleListings[num]), key, StringComparison.Ordinal))
				{
					Image snapshot = RowWidgets[i].Snapshot;
					if ((Object)(object)snapshot != (Object)null && Object.op_Implicit((Object)(object)snapshot))
					{
						snapshot.sprite = sprite;
						((Graphic)snapshot).color = Color.white;
						snapshot.preserveAspect = true;
					}
				}
			}
		}

		private static void ClearSnapshotDecodeQueue()
		{
			PendingSnapshotDecodes.Clear();
			PendingSnapshotDecodeKeys.Clear();
		}

		internal static Sprite GetItemIcon(ZoneBlueprintStorePriceItem item)
		{
			string text = ((!string.IsNullOrWhiteSpace(item.PrefabName)) ? item.PrefabName : ((!string.IsNullOrWhiteSpace(item.ItemName)) ? item.ItemName : (item.DisplayName ?? "")));
			if (!string.IsNullOrWhiteSpace(text) && ItemIconCache.TryGetValue(text, out Sprite value))
			{
				return value;
			}
			GameObject val = ZoneBlueprintStore.FindItemPrefab(item.PrefabName);
			ItemDrop val2 = (Object.op_Implicit((Object)(object)val) ? val.GetComponent<ItemDrop>() : null);
			Sprite val3 = (Sprite)(((Object)(object)val2 != (Object)null) ? ((object)val2.m_itemData.GetIcon()) : ((object)GetMissingPriceIcon()));
			if (!string.IsNullOrWhiteSpace(text))
			{
				ItemIconCache[text] = val3;
			}
			return val3;
		}

		private static Sprite GetMissingSnapshotSprite()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_00de: 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_00a8: 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)
			if ((Object)(object)_missingSnapshot != (Object)null)
			{
				return _missingSnapshot;
			}
			Texture2D val = new Texture2D(32, 32, (TextureFormat)4, false);
			Color val2 = default(Color);
			((Color)(ref val2))..ctor(0.05f, 0.12f, 0.14f, 1f);
			Color val3 = default(Color);
			((Color)(ref val3))..ctor(0.16f, 0.55f, 0.68f, 1f);
			for (int i = 0; i < 32; i++)
			{
				for (int j = 0; j < 32; j++)
				{
					bool flag = j < 3 || j > 28 || i < 3 || i > 28;
					bool flag2 = Mathf.Abs(j - i) <= 1 || Mathf.Abs(j + i - 31) <= 1;
					val.SetPixel(j, i, (flag || flag2) ? val3 : val2);
				}
			}
			val.Apply();
			_missingSnapshot = Sprite.Create(val, new Rect(0f, 0f, 32f, 32f), new Vector2(0.5f, 0.5f), 32f);
			return _missingSnapshot;
		}

		private static Sprite GetMissingPriceIcon()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_00b9: 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_0083: 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)
			if ((Object)(object)_missingPriceIcon != (Object)null)
			{
				return _missingPriceIcon;
			}
			Texture2D val = new Texture2D(16, 16, (TextureFormat)4, false);
			Color val2 = default(Color);
			((Color)(ref val2))..ctor(0.08f, 0.06f, 0.04f, 1f);
			Color val3 = default(Color);
			((Color)(ref val3))..ctor(1f, 0.72f, 0.18f, 1f);
			for (int i = 0; i < 16; i++)
			{
				for (int j = 0; j < 16; j++)
				{
					bool flag = (j - 8) * (j - 8) + (i - 8) * (i - 8) <= 36;
					val.SetPixel(j, i, flag ? val3 : val2);
				}
			}
			val.Apply();
			_missingPriceIcon = Sprite.Create(val, new Rect(0f, 0f, 16f, 16f), new Vector2(0.5f, 0.5f), 16f);
			return _missingPriceIcon;
		}

		internal static string FormatAmount(int amount)
		{
			if (amount < 1000)
			{
				return amount.ToString();
			}
			return $"{(float)amount / 1000f:0.#}k";
		}

		private static void PrimaryAction(int index)
		{
			if (index >= 0 && index < _visibleListings.Count)
			{
				ZoneBlueprintStoreListingSummaryDto zoneBlueprintStoreListingSummaryDto = _visibleListings[index];
				if (zoneBlueprintStoreListingSummaryDto.CanManage)
				{
					Close();
					ZoneBlueprintStorePriceInputUi.OpenEditPrice(zoneBlueprintStoreListingSummaryDto);
				}
				else
				{
					Close();
					ZoneBlueprintStore.RequestPreview(zoneBlueprintStoreListingSummaryDto.ListingId);
				}
			}
		}

		private static void RequestBuy(int index)
		{
			if (index >= 0 && index < _visibleListings.Count)
			{
				Close();
				ZoneBlueprintStore.RequestBuy(_visibleListings[index].ListingId);
			}
		}

		private static void OpenOfferInput(int index)
		{
			if (index >= 0 && index < _visibleListings.Count)
			{
				ZoneBlueprintStoreListingSummaryDto listing = _visibleListings[index];
				Close();
				ZoneBlueprintStorePriceInputUi.OpenOffer(listing);
			}
		}

		private static void OpenOfferList(int index)
		{
			if (index >= 0 && index < _visibleListings.Count)
			{
				ZoneBlueprintStoreListingSummaryDto zoneBlueprintStoreListingSummaryDto = _visibleListings[index];
				Close();
				ZoneBlueprintStoreOffersUi.Open(zoneBlueprintStoreListingSummaryDto.ListingId, zoneBlueprintStoreListingSummaryDto.Name);
				ZoneBlueprintStore.RequestOfferList(zoneBlueprintStoreListingSummaryDto.ListingId);
			}
		}

		private static void Delist(int index)
		{
			if (index >= 0 && index < _visibleListings.Count)
			{
				ZoneBlueprintStoreListingSummaryDto zoneBlueprintStoreListingSummaryDto = _visibleListings[index];
				if (!zoneBlueprintStoreListingSummaryDto.CanDelist)
				{
					SetStatus(HomesteadLocalization.Text("hs_store_only_seller_delist"));
					return;
				}
				SetStatus(HomesteadLocalization.Format("hs_store_delisting", zoneBlueprintStoreListingSummaryDto.Name));
				ZoneBlueprintStore.RequestDelist(zoneBlueprintStoreListingSummaryDto.ListingId);
			}
		}

		private static void SetStatus(string text)
		{
			if ((Object)(object)_statusText != (Object)null && Object.op_Implicit((Object)(object)_statusText))
			{
				_statusText.text = text;
			}
		}

		private static void Close()
		{
			if ((Object)(object)_panel != (Object)null && Object.op_Implicit((Object)(object)_panel))
			{
				_panel.SetActive(false);
			}
			SetInputBlocked(blocked: false);
		}

		private static bool IsPanelVisible()
		{
			if ((Object)(object)_panel != (Object)null && Object.op_Implicit((Object)(object)_panel))
			{
				return _panel.activeInHierarchy;
			}
			return false;
		}

		private static void SetInputBlocked(bool blocked)
		{
			if (_inputBlocked != blocked)
			{
				GUIManager.BlockInput(blocked);
				_inputBlocked = blocked;
			}
		}
	}
	internal static class ZoneBlueprintVisuals
	{
		private readonly struct ProjectedEntry
		{
			public ZoneBlueprintEntry Entry { get; }

			public float U { get; }

			public float V { get; }

			public float Depth { get; }

			public ProjectedEntry(ZoneBlueprintEntry entry, float u, float v, float depth)
			{
				Entry = entry;
				U = u;
				V = v;
				Depth = depth;
			}
		}

		private const int FullIconEntryLimit = 120;

		private const int MaxIconProjectionSourceEntries = 2500;

		private const int MaxOptimizedIconEntries = 180;

		private const int IconProjectionGrid = 18;

		private static readonly Vector3 IconViewToCamera;

		private static readonly Dictionary<string, Sprite?> IconCache;

		private static readonly Type? ImageConversionType;

		private static readonly MethodInfo? LoadImageMethod;

		private static readonly MethodInfo? EncodeToPngMethod;

		public static void InvalidateIcon(string name)
		{
			IconCache.Remove(name);
		}

		public static bool TryGetIcon(string name, out Sprite? icon)
		{
			if (IconCache.TryGetValue(name, out icon))
			{
				return true;
			}
			if (TryLoadIconFromDisk(name, out icon))
			{
				IconCache[name] = icon;
				return true;
			}
			return false;
		}

		public static string GetIconPngBase64(string name)
		{
			string blueprintIconPath = ZoneBlueprintCommands.GetBlueprintIconPath(name);
			if (!File.Exists(blueprintIconPath))
			{
				return "";
			}
			try
			{
				int maxIconBytes = BlueprintConfig.NetworkSettings.MaxIconBytes;
				if (maxIconBytes <= 0 || new FileInfo(blueprintIconPath).Length > maxIconBytes)
				{
					return "";
				}
				return Convert.ToBase64String(File.ReadAllBytes(blueprintIconPath));
			}
			catch
			{
				return "";
			}
		}

		public static Sprite? CreateIconFromBase64(string name, string payload)
		{
			//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_0026: Expected O, but got Unknown
			//IL_0057: 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)
			if (string.IsNullOrWhiteSpace(payload))
			{
				return null;
			}
			try
			{
				Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false)
				{
					name = "HomesteadStoreIcon_" + name
				};
				if (!TryLoadImage(val, Convert.FromBase64String(payload)))
				{
					Object.Destroy((Object)(object)val);
					return null;
				}
				return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f));
			}
			catch
			{
				return null;
			}
		}

		public static Sprite? RenderAndCacheIcon(string name, ZoneBlueprintFile blueprint)
		{
			Sprite val = RenderIcon(blueprint);
			IconCache[name] = val;
			SaveIconToDisk(name, val);
			return val;
		}

		public static bool EnqueueRenderAndCacheIcon(string name, ZoneBlueprintFile blueprint, Action<Sprite?> callback)
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0091: 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_00a7: Expected O, but got Unknown
			string name2 = name;
			Action<Sprite?> callback2 = callback;
			IReadOnlyList<ZoneBlueprintEntry> entries = SelectIconEntries(blueprint);
			GameObject root = CreateBlueprintVisualRoot(entries, "HomesteadBlueprintIconRender");
			if (root.transform.childCount == 0)
			{
				Object.Destroy((Object)(object)root);
				IconCache[name2] = null;
				callback2(null);
				return false;
			}
			bool finished = false;
			try
			{
				RenderRequest val = new RenderRequest(root)
				{
					Width = 256,
					Height = 256,
					Rotation = RenderManager.IsometricRotation,
					ParticleSimulationTime = -1f
				};
				bool num = RenderManager.Instance.EnqueueRender(val, (Action<Sprite>)Finish);
				if (!num && !finished)
				{
					Finish(null);
				}
				return num;
			}
			catch
			{
				Finish(null);
				throw;
			}
			void Finish(Sprite? icon)
			{
				if (finished)
				{
					return;
				}
				finished = true;
				try
				{
					IconCache[name2] = icon;
					SaveIconToDisk(name2, icon);
					callback2(icon);
				}
				finally
				{
					if (Object.op_Implicit((Object)(object)root))
					{
						Object.Destroy((Object)(object)root);
					}
				}
			}
		}

		public static GameObject CreateBlueprintVisualRoot(ZoneBlueprintFile blueprint, string objectName)
		{
			return CreateBlueprintVisualRoot(blueprint.Entries, objectName);
		}

		public static GameObject CreatePrefabVisualRoot(GameObject prefab, string objectName)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			GameObject val = new GameObject(objectName);
			if (CopyVisuals(prefab.transform, val.transform) == 0)
			{
				Object.Destroy((Object)(object)val);
				val = new GameObject(objectName);
			}
			return val;
		}

		private static GameObject CreateBlueprintVisualRoot(IEnumerable<ZoneBlueprintEntry> entries, string objectName)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(objectName);
			foreach (ZoneBlueprintEntry entry in entries)
			{
				GameObject prefab = ZNetScene.instance.GetPrefab(entry.Prefab);
				if (Object.op_Implicit((Object)(object)prefab))
				{
					GameObject val2 = new GameObject(entry.Prefab);
					val2.transform.SetParent(val.transform, false);
					val2.transform.localPosition = FromVector(entry.LocalPos);
					val2.transform.localRotation = FromQuaternion(entry.LocalRot);
					val2.transform.localScale = FromVector(entry.Scale);
					if (CopyVisuals(prefab.transform, val2.transform) == 0)
					{
						Object.Destroy((Object)(object)val2);
					}
				}
			}
			return val;
		}

		public static int CopyVisuals(Transform source, Transform target)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_004c: 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_006e: Unknown result type (might be due to invalid IL or missing references)
			if (!((Component)source).gameObject.activeSelf)
			{
				return 0;
			}
			int num = CopyRenderer(source, target);
			foreach (Transform item in source)
			{
				Transform val = item;
				GameObject val2 = new GameObject(((Object)val).name);
				val2.transform.SetParent(target, false);
				val2.transform.localPosition = val.localPosition;
				val2.transform.localRotation = val.localRotation;
				val2.transform.localScale = val.localScale;
				int num2 = CopyVisuals(val, val2.transform);
				if (num2 == 0)
				{
					Object.Destroy((Object)(object)val2);
				}
				num += num2;
			}
			return num;
		}

		private static int CopyRenderer(Transform source, Transform target)
		{
			MeshFilter component = ((Component)source).GetComponent<MeshFilter>();
			MeshRenderer component2 = ((Component)source).GetComponent<MeshRenderer>();
			if ((Object)(object)component != (Object)null && (Object)(object)component.sharedMesh != (Object)null && (Object)(object)component2 != (Object)null && ((Renderer)component2).enabled)
			{
				MeshFilter val = ((Component)target).gameObject.AddComponent<MeshFilter>();
				MeshRenderer obj = ((Component)target).gameObject.AddComponent<MeshRenderer>();
				val.sharedMesh = component.sharedMesh;
				((Renderer)obj).sharedMaterials = ((Renderer)component2).sharedMaterials;
				((Renderer)obj).shadowCastingMode = (ShadowCastingMode)0;
				((Renderer)obj).receiveShadows = false;
				return 1;
			}
			SkinnedMeshRenderer component3 = ((Component)source).GetComponent<SkinnedMeshRenderer>();
			if ((Object)(object)component3 != (Object)null && (Object)(object)component3.sharedMesh != (Object)null && ((Renderer)component3).enabled)
			{
				SkinnedMeshRenderer obj2 = ((Component)target).gameObject.AddComponent<SkinnedMeshRenderer>();
				obj2.sharedMesh = component3.sharedMesh;
				((Renderer)obj2).sharedMaterials = ((Renderer)component3).sharedMaterials;
				((Renderer)obj2).shadowCastingMode = (ShadowCastingMode)0;
				((Renderer)obj2).receiveShadows = false;
				return 1;
			}
			return 0;
		}

		private static Sprite? RenderIcon(ZoneBlueprintFile blueprint)
		{
			//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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: 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_0055: Expected O, but got Unknown
			GameObject val = CreateBlueprintVisualRoot(SelectIconEntries(blueprint), "HomesteadBlueprintIconRender");
			try
			{
				if (val.transform.childCount == 0)
				{
					return null;
				}
				RenderRequest val2 = new RenderRequest(val)
				{
					Width = 256,
					Height = 256,
					Rotation = RenderManager.IsometricRotation,
					ParticleSimulationTime = -1f
				};
				return RenderManager.Instance.Render(val2);
			}
			finally
			{
				Object.Destroy((Object)(object)val);
			}
		}

		private static bool TryLoadIconFromDisk(string name, out Sprite? icon)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0062: 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)
			icon = null;
			string blueprintIconPath = ZoneBlueprintCommands.GetBlueprintIconPath(name);
			if (!File.Exists(blueprintIconPath))
			{
				return false;
			}
			try
			{
				Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
				if (!TryLoadImage(val, File.ReadAllBytes(blueprintIconPath)))
				{
					Object.Destroy((Object)(object)val);
					return false;
				}
				((Object)val).name = "HomesteadBlueprintIcon_" + name;
				icon = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f));
				return true;
			}
			catch (Exception ex)
			{
				HomesteadPlugin.HomesteadLogger.LogDebug((object)("Failed to load Homestead blueprint icon '" + name + "' from disk: " + ex.Message));
				icon = null;
				return false;
			}
		}

		private static void SaveIconToDisk(string name, Sprite? icon)
		{
			if ((Object)(object)icon == (Object)null || (Object)(object)icon.texture == (Object)null)
			{
				return;
			}
			try
			{
				string blueprintIconPath = ZoneBlueprintCommands.GetBlueprintIconPath(name);
				Directory.CreateDirectory(Path.GetDirectoryName(blueprintIconPath));
				byte[] array = EncodeToPng(icon.texture);
				if (array != null)
				{
					File.WriteAllBytes(blueprintIconPath, array);
				}
			}
			catch (Exception ex)
			{
				HomesteadPlugin.HomesteadLogger.LogDebug((object)("Failed to save Homestead blueprint icon '" + name + "' to disk: " + ex.Message));
			}
		}

		private static bool TryLoadImage(Texture2D texture, byte[] data)
		{
			object obj = LoadImageMethod?.Invoke(null, new object[2] { texture, data });
			if (obj is bool)
			{
				return (bool)obj;
			}
			return false;
		}

		private static byte[]? EncodeToPng(Texture2D texture)
		{
			return EncodeToPngMethod?.Invoke(null, new object[1] { texture }) as byte[];
		}

		private static IReadOnlyList<ZoneBlueprintEntry> SelectIconEntries(ZoneBlueprintFile blueprint)
		{
			//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_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: 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_0065: 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_0070: 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_0079: 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_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: 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_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			if (blueprint.Entries.Count <= 120)
			{
				return blueprint.Entries;
			}
			Vector3 viewToCamera = IconViewToCamera;
			Vector3 val = Vector3.Cross(Vector3.up, viewToCamera);
			Vector3 screenRight = ((Vector3)(ref val)).normalized;
			if (((Vector3)(ref screenRight)).sqrMagnitude < 0.001f)
			{
				screenRight = Vector3.right;
			}
			val = Vector3.Cross(viewToCamera, screenRight);
			Vector3 screenUp = ((Vector3)(ref val)).normalized;
			List<ZoneBlueprintEntry> entries = blueprint.Entries;
			int num = ((entries.Count <= 2500) ? 1 : Mathf.CeilToInt((float)entries.Count / 2500f));
			List<ProjectedEntry> list = new List<ProjectedEntry>(Mathf.CeilToInt((float)entries.Count / (float)num));
			float num2 = float.PositiveInfinity;
			float num3 = float.NegativeInfinity;
			float num4 = float.PositiveInfinity;
			float num5 = float.NegativeInfinity;
			for (int i = 0; i < entries.Count; i += num)
			{
				ZoneBlueprintEntry zoneBlueprintEntry = entries[i];
				Vector3 val2 = FromVector(zoneBlueprintEntry.LocalPos);
				float num6 = Vector3.Dot(val2, screenRight);
				float num7 = Vector3.Dot(val2, screenUp);
				float depth = Vector3.Dot(val2, viewToCamera);
				list.Add(new ProjectedEntry(zoneBlueprintEntry, num6, num7, depth));
				num2 = Mathf.Min(num2, num6);
				num3 = Mathf.Max(num3, num6);
				num4 = Mathf.Min(num4, num7);
				num5 = Mathf.Max(num5, num7);
			}
			float num8 = Mathf.Max(0.001f, num3 - num2);
			float num9 = Mathf.Max(0.001f, num5 - num4);
			Dictionary<int, ProjectedEntry> dictionary = new Dictionary<int, ProjectedEntry>();
			foreach (ProjectedEntry item in list)
			{
				int num10 = Mathf.Clamp(Mathf.FloorToInt((item.U - num2) / num8 * 18f), 0, 17);
				int num11 = Mathf.Clamp(Mathf.FloorToInt((item.V - num4) / num9 * 18f), 0, 17);
				int key = num10 + num11 * 18;
				if (!dictionary.TryGetValue(key, out var value) || item.Depth > value.Depth)
				{
					dictionary[key] = item;
				}
			}
			HashSet<ZoneBlueprintEntry> hashSet = dictionary.Values.Select((ProjectedEntry item) => item.Entry).ToHashSet();
			AddExtremes(list, hashSet);
			return (from item in (from item in hashSet.Select(delegate(ZoneBlueprintEntry entry)
					{
						//IL_0006: Unknown result type (might be due to invalid IL or missing references)
						//IL_000b: Unknown result type (might be due to invalid IL or missing references)
						//IL_000d: 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_001b: 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_0027: Unknown result type (might be due to invalid IL or missing references)
						Vector3 val3 = FromVector(entry.LocalPos);
						return new ProjectedEntry(entry, Vector3.Dot(val3, screenRight), Vector3.Dot(val3, screenUp), Vector3.Dot(val3, viewToCamera));
					})
					orderby item.Depth descending, item.V, item.U
					select item).Take(180)
				select item.Entry).ToList();
		}

		private static void AddExtremes(List<ProjectedEntry> projected, HashSet<ZoneBlueprintEntry> selected)
		{
			if (projected.Count != 0)
			{
				AddExtreme(projected, selected, (ProjectedEntry item) => item.U, maximize: false);
				AddExtreme(projected, selected, (ProjectedEntry item) => item.U, maximize: true);
				AddExtreme(projected, selected, (ProjectedEntry item) => item.V, maximize: false);
				AddExtreme(projected, selected, (ProjectedEntry item) => item.V, maximize: true);
				AddExtreme(projected, selected, (ProjectedEntry item) => FromVector(item.Entry.LocalPos).y, maximize: false);
				AddExtreme(projected, selected, (ProjectedEntry item) => FromVector(item.Entry.LocalPos).y, maximize: true);
			}
		}

		private static void AddExtreme(IReadOnlyList<ProjectedEntry> projected, HashSet<ZoneBlueprintEntry> selected, Func<ProjectedEntry, float> getValue, bool maximize)
		{
			ProjectedEntry arg = projected[0];
			float num = getValue(arg);
			for (int i = 1; i < projected.Count; i++)
			{
				ProjectedEntry projectedEntry = projected[i];
				float num2 = getValue(projectedEntry);
				if (maximize ? (num2 > num) : (num2 < num))
				{
					arg = projectedEntry;
					num = num2;
				}
			}
			selected.Add(arg.Entry);
		}

		private static Vector3 FromVector(float[] value)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(value[0], value[1], value[2]);
		}

		private static Quaternion FromQuaternion(float[] value)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return new Quaternion(value[0], value[1], value[2], value[3]);
		}

		static ZoneBlueprintVisuals()
		{
			//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_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)
			Vector3 val = new Vector3(0.75f, 0.55f, -0.75f);
			IconViewToCamera = ((Vector3)(ref val)).normalized;
			IconCache = new Dictionary<string, Sprite>();
			ImageConversionType = Type.GetType("UnityEngine.ImageConversion, UnityEngine.ImageConversionModule");
			LoadImageMethod = ImageConversionType?.GetMethod("LoadImage", BindingFlags.Static | BindingFlags.Public, null, new Type[2]
			{
				typeof(Texture2D),
				typeof(byte[])
			}, null);
			EncodeToPngMethod = ImageConversionType?.GetMethod("EncodeToPNG", BindingFlags.Static | BindingFlags.Public, null, new Type[1] { typeof(Texture2D) }, null);
		}
	}
	internal static class ZoneGridSnap
	{
		[HarmonyPatch(typeof(Player), "UpdatePlacementGhost")]
		private static class PlayerUpdatePlacementGhostPatch
		{
			private static void Postfix(Player __instance)
			{
				if (IsLocalPlacementContext(__instance) && _active)
				{
					SnapPlacementGhost(__instance);
				}
			}
		}

		private static ManualLogSource Log;

		private static bool _active;

		internal static bool IsActive => _active;

		private static Vector3 SnapPosition(Vector3 position)
		{
			//IL_0011: 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_0035: 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)
			if (!_active)
			{
				return position;
			}
			float gridSnapSize = PlacementControlConfig.GridSnapSize;
			position.x = RoundToGrid(position.x, gridSnapSize);
			position.z = RoundToGrid(position.z, gridSnapSize);
			return position;
		}

		internal static void Initialize(ManualLogSource logger)
		{
			Log = logger;
		}

		internal static void Update()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			if (IsLocalPlaceModeContext() && IsShortcutDownLenient(PlacementControlConfig.GridSnapToggleHotkey))
			{
				_active = !_active;
				Log.LogDebug((object)("Grid Snap toggled " + (_active ? "on" : "off") + "."));
			}
		}

		private static bool IsLocalPlacementContext(Player player)
		{
			if (IsLocalPlaceModeContext() && (Object)(object)player == (Object)(object)Player.m_localPlayer)
			{
				return Object.op_Implicit((Object)(object)player.m_placementGhost);
			}
			return false;
		}

		private static bool IsLocalPlaceModeContext()
		{
			Player localPlayer = Player.m_localPlayer;
			if (Object.op_Implicit((Object)(object)localPlayer) && ((Character)localPlayer).InPlaceMode() && !((Character)localPlayer).IsDead() && ((Character)localPlayer).TakeInput() && !Console.IsVisible() && !TextInput.IsVisible())
			{
				return !Menu.IsVisible();
			}
			return false;
		}

		private static bool IsShortcutDownLenient(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)
			//IL_0029: 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 false;
			}
			foreach (KeyCode modifier in ((KeyboardShortcut)(ref shortcut)).Modifiers)
			{
				if (!IsShortcutModifierHeld(modifier))
				{
					return false;
				}
			}
			return true;
		}

		private static bool IsShortcutModifierHeld(KeyCode key)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: 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_0027: Expected I4, but got Unknown
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			if ((int)key != 0)
			{
				switch (key - 303)
				{
				case 0:
				case 1:
					return Input.GetKey((KeyCode)304) || Input.GetKey((KeyCode)303);
				case 2:
				case 3:
					return Input.GetKey((KeyCode)306) || Input.GetKey((KeyCode)305);
				case 4:
				case 5:
					return Input.GetKey((KeyCode)308) || Input.GetKey((KeyCode)307);
				default:
					return Input.GetKey(key);
				}
			}
			return true;
		}

		private static void SnapPlacementGhost(Player player)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if (!ShouldSkipGhost(player.m_placementGhost))
			{
				Transform transform = player.m_placementGhost.transform;
				transform.position = SnapPosition(transform.position);
			}
		}

		private static bool ShouldSkipGhost(GameObject ghost)
		{
			string name = ((Object)ghost).name;
			if (name.StartsWith("Homestead_BlueprintSaveTool") || name.StartsWith("Homestead_AreaDismantleTool"))
			{
				return true;
			}
			Piece component = ghost.GetComponent<Piece>();
			if (Object.op_Implicit((Object)(object)component))
			{
				if (!(component.m_name == "Area Save"))
				{
					return component.m_name == "Area Dismantle";
				}
				return true;
			}
			return false;
		}

		private static float RoundToGrid(float value, float grid)
		{
			if (grid <= 0f)
			{
				return value;
			}
			return Mathf.Round(value / grid) * grid;
		}
	}
	internal static class ZonePlacementOffset
	{
		public static Vector3 GetArrowKeyLocalNudge()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: 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_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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: 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_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: 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_005a: 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_0060: 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_007b: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = Vector3.zero;
			if (Input.GetKeyDown((KeyCode)273))
			{
				val += Vector3.forward;
			}
			if (Input.GetKeyDown((KeyCode)274))
			{
				val -= Vector3.forward;
			}
			if (Input.GetKeyDown((KeyCode)275))
			{
				val += Vector3.right;
			}
			if (Input.GetKeyDown((KeyCode)276))
			{
				val -= Vector3.right;
			}
			if (((Vector3)(ref val)).sqrMagnitude > 1f)
			{
				((Vector3)(ref val)).Normalize();
			}
			return val;
		}

		public static Vector3 ToWorldOffset(Quaternion rotation, Vector3 horizontalOffset, float heightOffset)
		{
			//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_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: 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)
			return rotation * Vector3.right * horizontalOffset.x + rotation * Vector3.up * heightOffset + rotation * Vector3.forward * horizontalOffset.z;
		}

		public static Vector3 ToWorldOffset(float yaw, Vector3 horizontalOffset, float heightOffset)
		{
			//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_0012: Unknown result type (might be due to invalid IL or missing references)
			return ToWorldOffset(Quaternion.Euler(0f, yaw, 0f), horizontalOffset, heightOffset);
		}
	}
	internal static class ZoneLimitCompat
	{
		private const string CounterTypeName = "ZoneSavior.ZonePieceCounter";

		private static Type? _counterType;

		private static MethodInfo? _canAddWearNTears;

		private static MethodInfo? _rebuildCounts;

		private static int _lastResolveAssemblyCount = -1;

		private static bool _counterUnavailable;

		public static bool CanAddWearNTears(IEnumerable<Vector3> positions, out string reason)
		{
			reason = "";
			if (!TryResolveCounter())
			{
				return true;
			}
			try
			{
				object[] array = new object[2] { positions, reason };
				bool valueOrDefault = (_canAddWearNTears?.Invoke(null, array) as bool?).GetValueOrDefault(true);
				reason = ((array.Length > 1) ? ((array[1] as string) ?? "") : "");
				return valueOrDefault;
			}
			catch (Exception ex)
			{
				reason = "";
				HomesteadPlugin.HomesteadLogger.LogWarning((object)("ZoneSavior zone limit bridge failed open: " + ex.Message));
				return true;
			}
		}

		public static void RebuildCounts()
		{
			if (!TryResolveCounter())
			{
				return;
			}
			try
			{
				_rebuildCounts?.Invoke(null, null);
			}
			catch (Exception ex)
			{
				HomesteadPlugin.HomesteadLogger.LogWarning((object)("ZoneSavior zone count rebuild bridge failed: " + ex.Message));
			}
		}

		private static bool TryResolveCounter()
		{
			if (_counterType != null && _canAddWearNTears != null && _rebuildCounts != null)
			{
				return true;
			}
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			if (_counterUnavailable && _lastResolveAssemblyCount == assemblies.Length)
			{
				return false;
			}
			_lastResolveAssemblyCount = assemblies.Length;
			_counterUnavailable = false;
			_counterType = (from assembly in assemblies
				where (object)assembly != typeof(ZoneLimitCompat).Assembly
				select assembly.GetType("ZoneSavior.ZonePieceCounter", throwOnError: false)).FirstOrDefault((Type type) => type != null);
			if (_counterType == null)
			{
				_counterUnavailable = true;
				return false;
			}
			_canAddWearNTears = _counterType.GetMethod("CanAddWearNTears", BindingFlags.Static | BindingFlags.Public);
			_rebuildCounts = _counterType.GetMethod("RebuildCounts", BindingFlags.Static | BindingFlags.Public);
			_counterUnavailable = _canAddWearNTears == null || _rebuildCounts == null;
			return !_counterUnavailable;
		}
	}
	internal static class ZoneMaterialEscrow
	{
		public sealed class Session
		{
			private readonly List<ZoneBlueprintRequirement> _requirements;

			private readonly Dictionary<string, ZoneBlueprintRequirement> _requirementsByItemName;

			private readonly Func<string, int> _getDeposited;

			private readonly Action<ZoneBlueprintRequirement, int> _acceptMaterial;

			public Session(IEnumerable<ZoneBlueprintRequirement> requirements, Func<string, int> getDeposited, Action<ZoneBlueprintRequirement, int> acceptMaterial)
			{
				_requirements = NormalizeRequirements(requirements);
				_requirementsByItemName = _requirements.ToDictionary<ZoneBlueprintRequirement, string>((ZoneBlueprintRequirement item) => item.ItemName, StringComparer.Ordinal);
				_getDeposited = getDeposited;
				_acceptMaterial = acceptMaterial;
			}

			public int AcceptNeededOnly(Inventory sourceInventory, ItemData item, int requestedAmount)
			{
				if (!TryGetAllowedRequirement(item, requestedAmount, out ZoneBlueprintRequirement requirement, out int allowed))
				{
					return 0;
				}
				int num = TakeAllowedAmount(sourceInventory, item, requestedAmount, allowed);
				if (num <= 0)
				{
					return 0;
				}
				_acceptMaterial(requirement, num);
				return num;
			}

			public int AcceptAllNeeded(Inventory sourceInventory, Func<ItemData, bool>? skip = null)
			{
				if (sourceInventory == null)
				{
					return 0;
				}
				int num = 0;
				foreach (ItemData item in sourceInventory.GetAllItems().ToList())
				{
					if (skip == null || !skip(item))
					{
						num += AcceptNeededOnly(sourceInventory, item, item.m_stack);
					}
				}
				return num;
			}

			public int AcceptPulled(ZoneBlueprintRequirement requirement, int amount)
			{
				if (requirement == null || amount <= 0)
				{
					return 0;
				}
				if (!_requirementsByItemName.TryGetValue(requirement.ItemName, out ZoneBlueprintRequirement value))
				{
					return 0;
				}
				int num = value.Amount - Mathf.Max(0, _getDeposited(value.ItemName));
				int num2 = Mathf.Min(Mathf.Max(0, amount), Mathf.Max(0, num));
				if (num2 <= 0)
				{
					return 0;
				}
				_acceptMaterial(value, num2);
				return num2;
			}

			public AbsorbResult AbsorbUnexpectedInventoryItems(Inventory inventory, Vector3 dropPosition, bool preferInventory)
			{
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				if (inventory == null)
				{
					return default(AbsorbResult);
				}
				bool flag = false;
				int num = 0;
				int num2 = 0;
				foreach (ItemData item in inventory.GetAllItems().ToList())
				{
					int stack = item.m_stack;
					int num3 = AcceptNeededOnly(inventory, item, stack);
					num += num3;
					int num4 = stack - num3;
					if (num4 > 0)
					{
						ReturnOrDropFromInventory(inventory, item, num4, dropPosition, preferInventory);
						num2 += num4;
						flag = true;
					}
					flag = flag || num3 > 0;
				}
				return new AbsorbResult(flag, num, num2);
			}

			public List<ZoneBlueprintRequirement> GetMissingRequirements()
			{
				List<ZoneBlueprintRequirement> list = new List<ZoneBlueprintRequirement>();
				foreach (ZoneBlueprintRequirement requirement in _requirements)
				{
					int num = requirement.Amount - Mathf.Max(0, _getDeposited(requirement.ItemName));
					if (num > 0)
					{
						list.Add(new ZoneBlueprintRequirement
						{
							ItemName = requirement.ItemName,
							PrefabName = requirement.PrefabName,
							DisplayName = requirement.DisplayName,
							Amount = num
						});
					}
				}
				return list;
			}

			public string FormatDeposited()
			{
				List<string> list = new List<string>();
				foreach (ZoneBlueprintRequirement requirement in _requirements)
				{
					string arg = ((Localization.instance != null) ? Localization.instance.Localize(requirement.DisplayName) : requirement.DisplayName);
					list.Add($"{arg}: {_getDeposited(requirement.ItemName)}/{requirement.Amount}");
				}
				if (list.Count != 0)
				{
					return string.Join("\n", list);
				}
				return "No price";
			}

			public bool HasAllRequired(out string deposited)
			{
				deposited = FormatDeposited();
				if (_requirements.Count == 0)
				{
					return false;
				}
				foreach (ZoneBlueprintRequirement requirement in _requirements)
				{
					if (_getDeposited(requirement.ItemName) < requirement.Amount)
					{
						return false;
					}
				}
				return true;
			}

			private static void ReturnOrDropFromInventory(Inventory inventory, ItemData item, int amount, Vector3 dropPosition, bool preferInventory)
			{
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				if (amount > 0 && item != null)
				{
					ItemData prototype = item.Clone();
					if (inventory.ContainsItem(item))
					{
						inventory.RemoveItem(item, amount);
					}
					GiveOrDropItem(prototype, amount, dropPosition, preferInventory, item.m_dropPrefab);
				}
			}

			private bool TryGetAllowedRequirement(ItemData item, int requestedAmount, out ZoneBlueprintRequirement requirement, out int allowed)
			{
				requirement = null;
				allowed = 0;
				if (item == null || requestedAmount <= 0)
				{
					return false;
				}
				if (!_requirementsByItemName.TryGetValue(item.m_shared.m_name, out requirement))
				{
					return false;
				}
				allowed = requirement.Amount - Mathf.Max(0, _getDeposited(requirement.ItemName));
				return allowed > 0;
			}
		}

		public readonly struct AbsorbResult
		{
			public bool Changed { get; }

			public int Accepted { get; }

			public int Returned { get; }

			public AbsorbResult(bool changed, int accepted, int returned)
			{
				Changed = changed;
				Accepted = accepted;
				Returned = returned;
			}
		}

		public static List<ZoneBlueprintRequirement> NormalizeRequirements(IEnumerable<ZoneBlueprintRequirement> items, int maxTypes = int.MaxValue)
		{
			Dictionary<string, ZoneBlueprintRequirement> dictionary = new Dictionary<string, ZoneBlueprintRequirement>(StringComparer.Ordinal);
			foreach (ZoneBlueprintRequirement item in items)
			{
				if (item.Amount > 0 && !string.IsNullOrWhiteSpace(item.ItemName))
				{
					if (!dictionary.TryGetValue(item.ItemName, out var value))
					{
						value = new ZoneBlueprintRequirement
						{
							ItemName = item.ItemName,
							PrefabName = item.PrefabName,
							DisplayName = (string.IsNullOrWhiteSpace(item.DisplayName) ? item.ItemName : item.DisplayName)
						};
						dictionary[item.ItemName] = value;
					}
					if (string.IsNullOrWhiteSpace(value.PrefabName))
					{
						value.PrefabName = item.PrefabName;
					}
					if (string.IsNullOrWhiteSpace(value.DisplayName))
					{
						value.DisplayName = item.DisplayName;
					}
					value.Amount += item.Amount;
				}
			}
			return dictionary.Values.OrderBy<ZoneBlueprintRequirement, string>((ZoneBlueprintRequirement item) => item.DisplayName, StringComparer.Ordinal).Take(maxTypes).ToList();
		}

		public static List<ZoneBlueprintRequirement> ToRequirements(IEnumerable<ZoneBlueprintStorePriceItem> items, int maxTypes = int.MaxValue)
		{
			return NormalizeRequirements(items.Select((ZoneBlueprintStorePriceItem item) => new ZoneBlueprintRequirement
			{
				ItemName = item.ItemName,
				PrefabName = item.PrefabName,
				DisplayName = item.DisplayName,
				Amount = item.Amount
			}), maxTypes);
		}

		public static List<ZoneBlueprintStorePriceItem> ToPriceItems(IEnumerable<ZoneBlueprintRequirement> items, int maxTypes = int.MaxValue)
		{
			return (from item in NormalizeRequirements(items, maxTypes)
				select new ZoneBlueprintStorePriceItem
				{
					ItemName = item.ItemName,
					PrefabName = item.PrefabName,
					DisplayName = item.DisplayName,
					Amount = item.Amount
				}).ToList();
		}

		public static List<ZoneBlueprintStorePriceItem> ReadPriceItems(Inventory? inventory, int maxTypes = int.MaxValue)
		{
			if (inventory == null)
			{
				return new List<ZoneBlueprintStorePriceItem>();
			}
			List<ZoneBlueprintRequirement> list = new List<ZoneBlueprintRequirement>();
			foreach (ItemData allItem in inventory.GetAllItems())
			{
				if (allItem.m_stack > 0 && !allItem.m_shared.m_questItem && !((Object)(object)allItem.m_dropPrefab == (Object)null))
				{
					list.Add(new ZoneBlueprintRequirement
					{
						ItemName = allItem.m_shared.m_name,
						PrefabName = Utils.GetPrefabName(allItem.m_dropPrefab),
						DisplayName = allItem.m_shared.m_name,
						Amount = allItem.m_stack
					});
				}
			}
			return ToPriceItems(list, maxTypes);
		}

		public static int CountItem(Inventory? inventory, string itemName)
		{
			string itemName2 = itemName;
			if (inventory != null)
			{
				return (from item in inventory.GetAllItems()
					where string.Equals(item.m_shared.m_name, itemName2, StringComparison.Ordinal)
					select item).Sum((ItemData item) => item.m_stack);
			}
			return 0;
		}

		public static int TakeAllowedAmount(Inventory sourceInventory, ItemData item, int requestedAmount, int remaining)
		{
			if (sourceInventory == null || item == null || requestedAmount <= 0 || remaining <= 0)
			{
				return 0;
			}
			int num = Mathf.Min(new int[3] { requestedAmount, remaining, item.m_stack });
			if (num <= 0 || !sourceInventory.RemoveItem(item, num))
			{
				return 0;
			}
			return num;
		}

		public static int AcceptAllowedFromInventory(Inventory sourceInventory, ItemData item, int requestedAmount, IEnumerable<ZoneBlueprintRequirement> requirements, Func<string, int> getDeposited, Action<ZoneBlueprintRequirement, int> acceptMaterial)
		{
			if (!TryGetAllowedRequirement(item, requestedAmount, requirements, getDeposited, out ZoneBlueprintRequirement requirement, out int allowed))
			{
				return 0;
			}
			int num = TakeAllowedAmount(sourceInventory, item, requestedAmount, allowed);
			if (num <= 0)
			{
				return 0;
			}
			acceptMaterial(requirement, num);
			return num;
		}

		public static int MoveAllowedToInventory(Inventory sourceInventory, ItemData item, int requestedAmount, Inventory destinationInventory, IEnumerable<ZoneBlueprintRequirement> requirements, Func<string, int> getDeposited)
		{
			if (sourceInventory == null || destinationInventory == null || !TryGetAllowedRequirement(item, requestedAmount, requirements, getDeposited, out ZoneBlueprintRequirement _, out int allowed))
			{
				return 0;
			}
			int destinationCapacity = GetDestinationCapacity(destinationInventory, item, Mathf.Min(new int[3] { requestedAmount, allowed, item.m_stack }));
			if (destinationCapacity <= 0 || !sourceInventory.RemoveItem(item, destinationCapacity))
			{
				return 0;
			}
			ItemData val = item.Clone();
			val.m_stack = destinationCapacity;
			ItemData val2 = val;
			if (val2.m_dropPrefab == null)
			{
				val2.m_dropPrefab = item.m_dropPrefab;
			}
			if (destinationInventory.AddItem(val))
			{
				return destinationCapacity;
			}
			sourceInventory.AddItem(val);
			return 0;
		}

		public static int MoveAllAllowedToInventory(Inventory sourceInventory, Inventory destinationInventory, IEnumerable<ZoneBlueprintRequirement> requirements, Func<string, int> getDeposited, Func<ItemData, bool>? skip = null)
		{
			if (sourceInventory == null || destinationInventory == null)
			{
				return 0;
			}
			int num = 0;
			foreach (ItemData item in sourceInventory.GetAllItems().ToList())
			{
				if (skip == null || !skip(item))
				{
					num += MoveAllowedToInventory(sourceInventory, item, item.m_stack, destinationInventory, requirements, getDeposited);
				}
			}
			return num;
		}

		public static int AddRequirementToInventory(Inventory? inventory, ZoneBlueprintRequirement requirement, int amount, Vector3 dropPosition)
		{
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			if (inventory == null || requirement == null || amount <= 0)
			{
				return 0;
			}
			GameObject val = ZoneBlueprintStore.FindItemPrefab(requirement.PrefabName);
			ItemDrop val2 = (Object.op_Implicit((Object)(object)val) ? val.GetComponent<ItemDrop>() : null);
			if ((Object)(object)val2 == (Object)null)
			{
				return 0;
			}
			int num = 0;
			int num2 = Mathf.Max(1, val2.m_itemData.m_shared.m_maxStackSize);
			int num3 = amount;
			while (num3 > 0)
			{
				int num4 = Mathf.Min(num3, num2);
				ItemData val3 = val2.m_itemData.Clone();
				val3.m_stack = num4;
				val3.m_dropPrefab = val;
				if (inventory.CanAddItem(val3, num4) && inventory.AddItem(val3))
				{
					num += num4;
				}
				else
				{
					DropItem(val3, num4, dropPosition);
				}
				num3 -= num4;
			}
			return num;
		}

		public static List<ZoneBlueprintRequirement> GetMissingRequirements(IEnumerable<ZoneBlueprintRequirement> requirements, Func<string, int> getDeposited)
		{
			List<ZoneBlueprintRequirement> list = new List<ZoneBlueprintRequirement>();
			foreach (ZoneBlueprintRequirement item in NormalizeRequirements(requirements))
			{
				int num = item.Amount - Mathf.Max(0, getDeposited(item.ItemName));
				if (num > 0)
				{
					list.Add(new ZoneBlueprintRequirement
					{
						ItemName = item.ItemName,
						PrefabName = item.PrefabName,
						DisplayName = item.DisplayName,
						Amount = num
					});
				}
			}
			return list;
		}

		public static bool TryTakeRequired(Inventory? inventory, IEnumerable<ZoneBlueprintStorePriceItem> priceItems, out string deposited)
		{
			List<ZoneBlueprintRequirement> list = ToRequirements(priceItems);
			deposited = FormatDeposited(inventory, list);
			if (!CanTakeRequired(inventory, list))
			{
				return false;
			}
			foreach (ZoneBlueprintRequirement item in list)
			{
				RemoveItem(inventory, item.ItemName, item.Amount);
			}
			return true;
		}

		public static bool CanTakeRequired(Inventory? inventory, IEnumerable<ZoneBlueprintStorePriceItem> priceItems, out string deposited)
		{
			List<ZoneBlueprintRequirement> list = ToRequirements(priceItems);
			deposited = FormatDeposited(inventory, list);
			return CanTakeRequired(inventory, list);
		}

		private static bool CanTakeRequired(Inventory? inventory, List<ZoneBlueprintRequirement> required)
		{
			if (inventory == null || required.Count == 0)
			{
				return false;
			}
			foreach (ZoneBlueprintRequirement item in required)
			{
				if (CountItem(inventory, item.ItemName) < item.Amount)
				{
					return false;
				}
			}
			return true;
		}

		private static bool TryGetAllowedRequirement(ItemData item, int requestedAmount, IEnumerable<ZoneBlueprintRequirement> requirements, Func<string, int> getDeposited, out ZoneBlueprintRequirement requirement, out int allowed)
		{
			ItemData item2 = item;
			requirement = null;
			allowed = 0;
			if (item2 == null || requestedAmount <= 0)
			{
				return false;
			}
			requirement = NormalizeRequirements(requirements).FirstOrDefault((ZoneBlueprintRequirement value) => value.ItemName == item2.m_shared.m_name);
			if (requirement == null)
			{
				return false;
			}
			allowed = requirement.Amount - Mathf.Max(0, getDeposited(requirement.ItemName));
			return allowed > 0;
		}

		private static int GetDestinationCapacity(Inventory destinationInventory, ItemData item, int requestedAmount)
		{
			for (int num = Mathf.Max(0, requestedAmount); num > 0; num--)
			{
				ItemData val = item.Clone();
				val.m_stack = num;
				ItemData val2 = val;
				if (val2.m_dropPrefab == null)
				{
					val2.m_dropPrefab = item.m_dropPrefab;
				}
				if (destinationInventory.CanAddItem(val, num))
				{
					return num;
				}
			}
			return 0;
		}

		public static bool CleanInventoryToRequirements(Inventory? inventory, IEnumerable<ZoneBlueprintStorePriceItem> priceItems, Vector3 dropPosition)
		{
			//IL_0084: 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)
			if (inventory == null)
			{
				return false;
			}
			List<ZoneBlueprintRequirement> source = ToRequirements(priceItems);
			bool result = false;
			Dictionary<string, int> dictionary = new Dictionary<string, int>();
			foreach (ItemData item in inventory.GetAllItems().ToList())
			{
				ZoneBlueprintRequirement zoneBlueprintRequirement = source.FirstOrDefault((ZoneBlueprintRequirement value) => value.ItemName == item.m_shared.m_name);
				if (zoneBlueprintRequirement == null)
				{
					int stack = item.m_stack;
					inventory.RemoveItem(item, stack);
					DropItem(item, stack, dropPosition);
					result = true;
					continue;
				}
				dictionary.TryGetValue(zoneBlueprintRequirement.ItemName, out var value2);
				int num = value2 + item.m_stack;
				dictionary[zoneBlueprintRequirement.ItemName] = num;
				if (num > zoneBlueprintRequirement.Amount)
				{
					int num2 = Mathf.Min(num - zoneBlueprintRequirement.Amount, item.m_stack);
					inventory.RemoveItem(item, num2);
					DropItem(item, num2, dropPosition);
					dictionary[zoneBlueprintRequirement.ItemName] -= num2;
					result = true;
				}
			}
			return result;
		}

		public static string FormatDeposited(Inventory? inventory, IEnumerable<ZoneBlueprintRequirement> requirements)
		{
			List<string> list = new List<string>();
			foreach (ZoneBlueprintRequirement item in NormalizeRequirements(requirements))
			{
				string arg = ((Localization.instance != null) ? Localization.instance.Localize(item.DisplayName) : item.DisplayName);
				list.Add($"{arg}: {CountItem(inventory, item.ItemName)}/{item.Amount}");
			}
			if (list.Count != 0)
			{
				return string.Join("\n", list);
			}
			return "No price";
		}

		public static bool TrySplitIntoStacks(IEnumerable<ZoneBlueprintStorePriceItem> payoutItems, out List<ZoneBlueprintStorePriceItem> stacks, out string reason)
		{
			stacks = new List<ZoneBlueprintStorePriceItem>();
			reason = "";
			foreach (ZoneBlueprintStorePriceItem item in ToPriceItems(ToRequirements(payoutItems)))
			{
				GameObject val = ZoneBlueprintStore.FindItemPrefab(item.PrefabName);
				ItemDrop val2 = (Object.op_Implicit((Object)(object)val) ? val.GetComponent<ItemDrop>() : null);
				if ((Object)(object)val2 == (Object)null)
				{
					reason = "Missing payout item prefab '" + item.PrefabName + "'.";
					return false;
				}
				int num = Mathf.Max(1, val2.m_itemData.m_shared.m_maxStackSize);
				int num2 = item.Amount;
				while (num2 > 0)
				{
					int num3 = Mathf.Min(num2, num);
					stacks.Add(new ZoneBlueprintStorePriceItem
					{
						ItemName = item.ItemName,
						PrefabName = item.PrefabName,
						DisplayName = item.DisplayName,
						Amount = num3
					});
					num2 -= num3;
				}
			}
			if (stacks.Count == 0)
			{
				reason = "No blueprint store payout materials found.";
				return false;
			}
			return true;
		}

		public static bool TryFillInventory(Inventory? inventory, IEnumerable<ZoneBlueprintStorePriceItem> stacks)
		{
			if (inventory == null)
			{
				return false;
			}
			foreach (ZoneBlueprintStorePriceItem stack in stacks)
			{
				GameObject val = ZoneBlueprintStore.FindItemPrefab(stack.PrefabName);
				ItemDrop val2 = (Object.op_Implicit((Object)(object)val) ? val.GetComponent<ItemDrop>() : null);
				if ((Object)(object)val2 == (Object)null || stack.Amount <= 0)
				{
					return false;
				}
				ItemData val3 = val2.m_itemData.Clone();
				val3.m_stack = stack.Amount;
				val3.m_dropPrefab = val;
				if (!inventory.AddItem(val3))
				{
					return false;
				}
			}
			return true;
		}

		public static void DropAllContents(Inventory? inventory, Vector3 dropPosition)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			if (inventory == null)
			{
				return;
			}
			foreach (ItemData item in inventory.GetAllItems().ToList())
			{
				int stack = item.m_stack;
				inventory.RemoveItem(item, stack);
				DropItem(item, stack, dropPosition);
			}
		}

		public static void DropPriceItems(IEnumerable<ZoneBlueprintStorePriceItem> priceItems, Vector3 dropPosition)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			foreach (ZoneBlueprintStorePriceItem item in ToPriceItems(ToRequirements(priceItems)))
			{
				GameObject val = ZoneBlueprintStore.FindItemPrefab(item.PrefabName);
				ItemDrop val2 = (Object.op_Implicit((Object)(object)val) ? val.GetComponent<ItemDrop>() : null);
				if (!((Object)(object)val2 == (Object)null) && item.Amount > 0)
				{
					ItemData obj = val2.m_itemData.Clone();
					obj.m_dropPrefab = val;
					DropItem(obj, item.Amount, dropPosition);
				}
			}
		}

		public static void DropItemStack(ItemData item, int amount, Vector3 dropPosition)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			DropItem(item, amount, dropPosition);
		}

		public static void GiveOrDropItem(ItemData prototype, int amount, Vector3 dropPosition, bool preferInventory, GameObject? dropPrefab = null)
		{
			//IL_0098: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: 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)
			int num = Mathf.Max(1, prototype.m_shared.m_maxStackSize);
			int num2 = amount;
			while (num2 > 0)
			{
				int num3 = Mathf.Min(num2, num);
				ItemData val = prototype.Clone();
				val.m_stack = num3;
				if ((Object)(object)val.m_dropPrefab == (Object)null && (Object)(object)dropPrefab != (Object)null)
				{
					val.m_dropPrefab = dropPrefab;
				}
				Inventory val2 = ((preferInventory && (Object)(object)Player.m_localPlayer != (Object)null) ? ((Humanoid)Player.m_localPlayer).GetInventory() : null);
				if (val2 != null && val2.CanAddItem(val, num3))
				{
					val2.AddItem(val);
				}
				else if ((Object)(object)val.m_dropPrefab != (Object)null)
				{
					ItemDrop.DropItem(val, 0, dropPosition + Vector3.up * 0.75f + Random.insideUnitSphere * 0.25f, Random.rotation);
				}
				num2 -= num3;
			}
		}

		private static int RemoveItem(Inventory inventory, string itemName, int amount)
		{
			int num = amount;
			foreach (ItemData item in inventory.GetAllItems().ToList())
			{
				if (num <= 0)
				{
					break;
				}
				if (string.Equals(item.m_shared.m_name, itemName, StringComparison.Ordinal))
				{
					int num2 = Mathf.Min(num, item.m_stack);
					if (inventory.RemoveItem(item, num2))
					{
						num -= num2;
					}
				}
			}
			return amount - num;
		}

		private static void DropItem(ItemData prototype, int amount, Vector3 dropPosition)
		{
			//IL_0023: 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_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_0038: Unknown result type (might be due to invalid IL or missing references)
			if (amount > 0)
			{
				ItemData val = prototype.Clone();
				val.m_stack = amount;
				if ((Object)(object)val.m_dropPrefab != (Object)null)
				{
					ItemDrop.DropItem(val, 0, dropPosition + Vector3.up * 0.75f, Random.rotation);
				}
			}
		}
	}
	internal static class ZonePlacementAdjust
	{
		[HarmonyPatch(typeof(Player), "UpdatePlacementGhost")]
		private static class PlayerUpdatePlacementGhostPatch
		{
			[HarmonyPriority(800)]
			private static void Prefix(Player __instance)
			{
				ApplyNativeRotationStep(__instance);
			}

			[HarmonyPriority(200)]
			private static void Postfix(Player __instance)
			{
				//IL_0084: 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_008d: 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 (!IsLocalPlacementContext(__instance))
				{
					ResetOffsets();
					return;
				}
				GameObject placementGhost = __instance.m_placementGhost;
				if (ShouldSkipGhost(placementGhost))
				{
					ResetOffsets(hideHud: false);
					return;
				}
				ResetOffsetsForGhost(GetStableGhostName(placementGhost));
				HandleInput(__instance);
				bool num = Mathf.Abs(_heightOffset) >= 0.0001f || ((Vector3)(ref _horizontalOffset)).sqrMagnitude >= 0.0001f;
				bool hasPlacementAxisRotation = PlacementControlConfig.HasPlacementAxisRotation;
				if (num)
				{
					ApplyOffset(__instance, placementGhost);
				}
				if (hasPlacementAxisRotation)
				{
					ApplyAxisRotation(placementGhost);
				}
				RevalidateFinalPlacement(__instance, placementGhost);
				Quaternion rotation = placementGhost.transform.rotation;
				float yaw = NormalizeAngle(((Quaternion)(ref rotation)).eulerAngles.y);
				bool flag = HasHudYawChanged(yaw);
				bool flag2 = num || hasPlacementAxisRotation || HasNonZeroYaw(yaw) || UsesNonVanillaRotationStep();
				if (!flag2 && !flag)
				{
					ZoneAreaToolStatusHud.HideDefaultPlacement();
				}
				else
				{
					ZoneAreaToolStatusHud.ShowDefaultPlacement(_horizontalOffset, _heightOffset, yaw, PlacementControlConfig.XAxisRotation, PlacementControlConfig.ZAxisRotation, flag2);
				}
			}
		}

		[HarmonyPatch(typeof(Player), "SetupPlacementGhost")]
		private static class PlayerSetupPlacementGhostRotationPatch
		{
			[HarmonyPriority(0)]
			private static void Postfix(Player __instance)
			{
				ApplyNativeRotationStep(__instance);
				RandomizeFullCircleRotationForGhost(__instance);
			}
		}

		[HarmonyPatch(typeof(Player), "PlacePiece")]
		private static class PlayerPlacePieceRotationPatch
		{
			[HarmonyPriority(0)]
			private static void Postfix(Player __instance, Piece piece)
			{
				ApplyNativeRotationStep(__instance);
				RandomizeFullCircleRotationForPiece(__instance, piece);
			}
		}

		[HarmonyPatch(typeof(Player), "CopyPiece")]
		private static class PlayerCopyPieceRotationPatch
		{
			[HarmonyPriority(800)]
			private static void Prefix(Player __instance)
			{
				ApplyNativeRotationStep(__instance);
			}
		}

		[HarmonyPatch(typeof(Player), "Update")]
		private static class PlayerUpdatePatch
		{
			private static void Postfix(Player __instance)
			{
				if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer) && (Input.GetKeyDown((KeyCode)27) || !((Character)__instance).InPlaceMode() || !Object.op_Implicit((Object)(object)__instance.m_placementGhost) || ((Character)__instance).IsDead()))
				{
					ResetOffsets();
				}
			}
		}

		private const float VanillaPlacementRotationStep = 22.5f;

		private static ManualLogSource Log = null;

		private static string _lastGhostName = "";

		private static float _heightOffset;

		private static Vector3 _horizontalOffset;

		private static float _lastHudYaw = float.NaN;

		internal static void Initialize(ManualLogSource logger)
		{
			Log = logger;
		}

		private static bool IsLocalPlacementContext(Player player)
		{
			if ((PlacementControlConfig.PlacementAdjustEnabled || PlacementControlConfig.HasPlacementAxisRotation) && Object.op_Implicit((Object)(object)Player.m_localPlayer) && (Object)(object)player == (Object)(object)Player.m_localPlayer && ((Character)player).InPlaceMode() && !((Character)player).IsDead())
			{
				return Object.op_Implicit((Object)(object)player.m_placementGhost);
			}
			return false;
		}

		private static bool IsLocalPlayer(Player? player)
		{
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && (Object)(object)player != (Object)null && (Object)(object)player == (Object)(object)Player.m_localPlayer)
			{
				return !((Character)player).IsDead();
			}
			return false;
		}

		private static void ApplyNativeRotationStep(Player player)
		{
			if (!IsLocalPlayer(player))
			{
				return;
			}
			float rotationStep = GetRotationStep();
			float placeRotationDegrees = player.m_placeRotationDegrees;
			if (!(Mathf.Abs(placeRotationDegrees - rotationStep) <= 0.001f))
			{
				if (placeRotationDegrees > 0.001f)
				{
					float num = placeRotationDegrees * (float)player.m_placeRotation;
					player.m_placeRotation = Mathf.RoundToInt(num / rotationStep);
				}
				player.m_placeRotationDegrees = rotationStep;
			}
		}

		private static void RandomizeFullCircleRotationForGhost(Player player)
		{
			GameObject val = (((Object)(object)player != (Object)null) ? player.m_placementGhost : null);
			Piece piece = (((Object)(object)val != (Object)null) ? val.GetComponent<Piece>() : null);
			RandomizeFullCircleRotationForPiece(player, piece);
		}

		private static void RandomizeFullCircleRotationForPiece(Player? player, Piece? piece)
		{
			if (!((Object)(object)player == (Object)null) && IsLocalPlayer(player) && !((Object)(object)piece == (Object)null) && piece.m_randomInitBuildRotation)
			{
				player.m_placeRotation = Random.Range(0, GetRotationSlotCount());
			}
		}

		private static int GetRotationSlotCount()
		{
			return Mathf.Max(1, Mathf.CeilToInt(360f / GetRotationStep()));
		}

		private static float GetRotationStep()
		{
			return Mathf.Clamp(PlacementControlConfig.RotationStep, 1f, 90f);
		}

		private static void ResetOffsetsForGhost(string ghostName)
		{
			//IL_001f: 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)
			if (!string.Equals(_lastGhostName, ghostName, StringComparison.Ordinal))
			{
				_lastGhostName = ghostName;
				_heightOffset = 0f;
				_horizontalOffset = Vector3.zero;
				_lastHudYaw = float.NaN;
				ZoneAreaToolStatusHud.HideDefaultPlacement();
			}
		}

		private static void ResetOffsets(bool hideHud = true)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			_lastGhostName = "";
			_heightOffset = 0f;
			_horizontalOffset = Vector3.zero;
			_lastHudYaw = float.NaN;
			if (hideHud)
			{
				ZoneAreaToolStatusHud.HideDefaultPlacement();
			}
		}

		private static bool HasHudYawChanged(float yaw)
		{
			if (float.IsNaN(_lastHudYaw))
			{
				_lastHudYaw = yaw;
				return false;
			}
			if (Mathf.Abs(Mathf.DeltaAngle(_lastHudYaw, yaw)) <= 0.1f)
			{
				return false;
			}
			_lastHudYaw = yaw;
			return true;
		}

		private static float NormalizeAngle(float angle)
		{
			angle = Mathf.Repeat(angle, 360f);
			if (!(Mathf.Abs(angle - 360f) <= 0.001f))
			{
				return angle;
			}
			return 0f;
		}

		private static bool HasNonZeroYaw(float yaw)
		{
			return Mathf.Abs(Mathf.DeltaAngle(0f, yaw)) > 0.1f;
		}

		private static bool UsesNonVanillaRotationStep()
		{
			return Mathf.Abs(GetRotationStep() - 22.5f) > 0.001f;
		}

		private static void HandleInput(Player player)
		{
			//IL_0063: 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_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_0082: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
			if (!PlacementControlConfig.PlacementAdjustEnabled || ShouldBlockInput())
			{
				return;
			}
			bool flag = false;
			if (PlacementControlConfig.IsPlacementAdjustModifierHeld())
			{
				if (Input.GetKeyDown((KeyCode)280) || Input.GetKeyDown((KeyCode)281))
				{
					float num = (Input.GetKeyDown((KeyCode)280) ? 1f : (-1f));
					_heightOffset = RoundOffset(_heightOffset + num * PlacementControlConfig.HeightStep);
					flag = true;
				}
				Vector3 arrowKeyLocalNudge = ZonePlacementOffset.GetArrowKeyLocalNudge();
				if (((Vector3)(ref arrowKeyLocalNudge)).sqrMagnitude > 0.0001f)
				{
					_horizontalOffset += arrowKeyLocalNudge * PlacementControlConfig.HorizontalStep;
					flag = true;
				}
				if (flag)
				{
					Log.LogDebug((object)FormatPlacementOffset("Default", _horizontalOffset, _heightOffset));
				}
			}
		}

		private static void ApplyOffset(Player player, GameObject ghost)
		{
			//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_0013: 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_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = ghost.transform;
			Vector3 position = transform.position + ZonePlacementOffset.ToWorldOffset(transform.rotation, _horizontalOffset, _heightOffset);
			transform.position = position;
			Physics.SyncTransforms();
		}

		private static void ApplyAxisRotation(GameObject ghost)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			Transform transform = ghost.transform;
			Quaternion val = Quaternion.Euler(PlacementControlConfig.XAxisRotation, 0f, PlacementControlConfig.ZAxisRotation);
			transform.rotation *= val;
			Physics.SyncTransforms();
		}

		private static void RevalidateFinalPlacement(Player player, GameObject ghost)
		{
			//IL_0001: 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_0028: 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_005c: 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_0065: 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_0076: 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_0088: 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_00c6: 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_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Invalid comparison between Unknown and I4
			//IL_0095: 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_00a0: 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_00a9: 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)
			if ((int)player.m_placementStatus != 0)
			{
				player.SetPlacementGhostValid(false);
				return;
			}
			Piece component = ghost.GetComponent<Piece>();
			if (Object.op_Implicit((Object)(object)component))
			{
				PlacementStatus val = (PlacementStatus)0;
				if (Location.IsInsideNoBuildLocation(ghost.transform.position))
				{
					val = (PlacementStatus)3;
				}
				PrivateArea component2 = ((Component)component).GetComponent<PrivateArea>();
				float num = (Object.op_Implicit((Object)(object)component2) ? component2.m_radius : 0f);
				bool flag = (Object)(object)component2 != (Object)null;
				if ((int)val == 0 && !PrivateArea.CheckAccess(ghost.transform.position, num, false, flag))
				{
					val = (PlacementStatus)4;
				}
				if ((int)val == 0 && player.CheckPlacementGhostVSPlayers())
				{
					val = (PlacementStatus)2;
				}
				if ((int)val == 0 && (int)component.m_onlyInBiome != 0 && (Heightmap.FindBiome(ghost.transform.position) & component.m_onlyInBiome) == 0)
				{
					val = (PlacementStatus)8;
				}
				if ((int)val == 0 && component.m_noClipping && player.TestGhostClipping(ghost, 0.2f))
				{
					val = (PlacementStatus)1;
				}
				player.m_placementStatus = val;
				player.SetPlacementGhostValid((int)val == 0);
			}
		}

		private static bool ShouldSkipGhost(GameObject ghost)
		{
			if (GetStableGhostName(ghost).StartsWith("Homestead_", StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			if (Object.op_Implicit((Object)(object)ghost.GetComponent<TerrainOp>()))
			{
				return true;
			}
			Piece component = ghost.GetComponent<Piece>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				return true;
			}
			if (!(component.m_name == "Area Save"))
			{
				return component.m_name == "Area Dismantle";
			}
			return true;
		}

		private static string GetStableGhostName(GameObject ghost)
		{
			string name = ((Object)ghost).name;
			if (!name.EndsWith("(Clone)", StringComparison.Ordinal))
			{
				return name;
			}
			return name.Substring(0, name.Length - "(Clone)".Length).Trim();
		}

		private static bool ShouldBlockInput()
		{
			if (!Hud.IsPieceSelectionVisible() && !Console.IsVisible() && !TextInput.IsVisible() && !Menu.IsVisible() && !InventoryGui.IsVisible())
			{
				return Minimap.IsOpen();
			}
			return true;
		}

		private static float RoundOffset(float value)
		{
			return Mathf.Round(value * 1000f) / 1000f;
		}

		private static string FormatOffset(float value)
		{
			return value.ToString("+0.###;-0.###;0", CultureInfo.InvariantCulture);
		}

		private static string FormatPlacementOffset(string label, Vector3 horizontalOffset, float heightOffset)
		{
			//IL_0014: 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)
			return label + " offset: X " + FormatOffset(horizontalOffset.x) + "m, Y " + FormatOffset(heightOffset) + "m, Z " + FormatOffset(horizontalOffset.z) + "m";
		}
	}
	internal static class ZoneToolAim
	{
		private const float NativePlacementRayDistance = 50f;

		public static bool TryGetAimPoint(Player player, float maxToolDistance, out Vector3 point)
		{
			//IL_0001: 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_003d: 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)
			point = default(Vector3);
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			if (TryGetCameraRay(out var origin, out var direction))
			{
				int num = ((player.m_placeRayMask != 0) ? player.m_placeRayMask : (-5));
				float num2 = Mathf.Max(50f, maxToolDistance);
				RaycastHit val = default(RaycastHit);
				if (Physics.Raycast(origin, direction, ref val, num2, num, (QueryTriggerInteraction)1))
				{
					point = ((RaycastHit)(ref val)).point;
					point.y = SampleGroundY(point.x, point.z, point.y);
					return true;
				}
			}
			return false;
		}

		public static float SampleGroundY(float x, float z, float fallbackY)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ZoneSystem.instance == (Object)null)
			{
				return fallbackY;
			}
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(x, fallbackY, z);
			Vector3 val2 = default(Vector3);
			Biome val3 = default(Biome);
			BiomeArea val4 = default(BiomeArea);
			Heightmap val5 = default(Heightmap);
			ZoneSystem.instance.GetGroundData(ref val, ref val2, ref val3, ref val4, ref val5);
			return val.y;
		}

		private static bool TryGetCameraRay(out Vector3 origin, out Vector3 direction)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0082: 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_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: 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_006d: 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_007a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)GameCamera.instance != (Object)null)
			{
				Transform transform = ((Component)GameCamera.instance).transform;
				origin = transform.position;
				direction = transform.forward;
				return true;
			}
			Camera mainCamera = Utils.GetMainCamera();
			if ((Object)(object)mainCamera != (Object)null)
			{
				Ray val = mainCamera.ScreenPointToRay(new Vector3((float)Screen.width * 0.5f, (float)Screen.height * 0.5f));
				origin = ((Ray)(ref val)).origin;
				direction = ((Ray)(ref val)).direction;
				return true;
			}
			origin = default(Vector3);
			direction = default(Vector3);
			return false;
		}
	}
	internal sealed class ZoneRpcRegistrar
	{
		private ZRoutedRpc? _registeredRoutedRpc;

		public bool EnsureRegistered(Action<ZRoutedRpc> register)
		{
			ZRoutedRpc instance = ZRoutedRpc.instance;
			if (instance == null || _registeredRoutedRpc == instance)
			{
				return false;
			}
			register(instance);
			_registeredRoutedRpc = instance;
			return true;
		}

		public void Reset()
		{
			_registeredRoutedRpc = null;
		}
	}
	internal interface IZoneSessionResettable
	{
		string Name { get; }

		void ResetForWorldSession();
	}
	internal static class ZoneSessionResetRegistry
	{
		private sealed class DelegateResettable : IZoneSessionResettable
		{
			private readonly Action _reset;

			public string Name { get; }

			public DelegateResettable(string name, Action reset)
			{
				Name = name;
				_reset = reset;
			}

			public void ResetForWorldSession()
			{
				_reset();
			}
		}

		private static readonly Dictionary<string, IZoneSessionResettable> Resetters = new Dictionary<string, IZoneSessionResettable>(StringComparer.Ordinal);

		private static ManualLogSource? _logger;

		public static void Initialize(ManualLogSource logger)
		{
			_logger = logger;
		}

		public static void Register(string name, Action reset)
		{
			if (!string.IsNullOrWhiteSpace(name) && reset != null)
			{
				Resetters[name] = new DelegateResettable(name, reset);
			}
		}

		public static void ResetForWorldSession(string reason)
		{
			foreach (IZoneSessionResettable value in Resetters.Values)
			{
				try
				{
					value.ResetForWorldSession();
				}
				catch (Exception ex)
				{
					ManualLogSource? logger = _logger;
					if (logger != null)
					{
						logger.LogWarning((object)("Failed to reset Homestead session cache '" + value.Name + "' (" + reason + "): " + ex.GetType().Name + ": " + ex.Message));
					}
				}
			}
		}
	}
	internal static class ZoneWorldEditTerrainCompat
	{
		private const string WorldEditCommandsGuid = "world_edit_commands";

		private static ManualLogSource? _logger;

		private static Harmony? _harmony;

		private static bool _patched;

		private static bool _missingLogged;

		internal static void Initialize(ManualLogSource logger, Harmony harmony)
		{
			_logger = logger;
			_harmony = harmony;
			TryPatch();
		}

		internal static void Update()
		{
			if (!_patched)
			{
				TryPatch();
			}
		}

		private static void TryPatch()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			if (_patched)
			{
				return;
			}
			MethodInfo methodInfo = GetWorldEditCommandsType("WorldEditCommands.Terrain")?.GetMethod("ResetTerrain", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			if (methodInfo == null)
			{
				if (!_missingLogged)
				{
					ManualLogSource? logger = _logger;
					if (logger != null)
					{
						logger.LogInfo((object)"WorldEditCommands terrain reset compat: WorldEditCommands.Terrain.ResetTerrain not found yet.");
					}
					_missingLogged = true;
				}
				return;
			}
			MethodInfo methodInfo2 = AccessTools.Method(typeof(ZoneWorldEditTerrainCompat), "ResetTerrainPostfix", (Type[])null, (Type[])null);
			Harmony? harmony = _harmony;
			if (harmony != null)
			{
				harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(methodInfo2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			_patched = true;
			ManualLogSource? logger2 = _logger;
			if (logger2 != null)
			{
				logger2.LogInfo((object)"WorldEditCommands terrain reset compat: patched terrain reset for Homestead support-fill base layers.");
			}
		}

		private static Type? GetWorldEditCommandsType(string fullName)
		{
			if (!Chainloader.PluginInfos.TryGetValue("world_edit_commands", out var value))
			{
				return null;
			}
			return (((object)value.Instance)?.GetType().Assembly)?.GetType(fullName, throwOnError: false);
		}

		private static void ResetTerrainPostfix(object __0, object __1, Vector3 __2, float __3)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				HomesteadTerrainSupport.ResetSupportFillBaseLayer(__0 as IEnumerable, __1 as IEnumerable, __2, __3);
			}
			catch (Exception arg)
			{
				ManualLogSource? logger = _logger;
				if (logger != null)
				{
					logger.LogWarning((object)$"WorldEditCommands terrain reset compat failed: {arg}");
				}
			}
		}
	}
}
namespace ServerSync
{
	[PublicAPI]
	internal abstract class OwnConfigEntryBase
	{
		public object? LocalBaseValue;

		public bool SynchronizedConfig = true;

		public abstract ConfigEntryBase BaseConfig { get; }
	}
	[PublicAPI]
	internal class SyncedConfigEntry<T> : OwnConfigEntryBase
	{
		public readonly ConfigEntry<T> SourceConfig;

		public override ConfigEntryBase BaseConfig => (ConfigEntryBase)(object)SourceConfig;

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

		public SyncedConfigEntry(ConfigEntry<T> sourceConfig)
		{
			SourceConfig = sourceConfig;
			base..ctor();
		}

		public void AssignLocalValue(T value)
		{
			if (LocalBaseValue == null)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	internal abstract class CustomSyncedValueBase
	{
		public object? LocalBaseValue;

		public readonly string Identifier;

		public readonly Type Type;

		private object? boxedValue;

		protected bool localIsOwner;

		public readonly int Priority;

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

		public event Action? ValueChanged;

		protected CustomSyncedValueBase(ConfigSync configSync, string identifier, Type type, int priority)
		{
			Priority = priority;
			Identifier = identifier;
			Type = type;
			configSync.AddCustomValue(this);
			localIsOwner = configSync.IsSourceOfTruth;
			configSync.SourceOfTruthChanged += delegate(bool truth)
			{
				localIsOwner = truth;
			};
		}
	}
	[PublicAPI]
	internal sealed class CustomSyncedValue<T> : CustomSyncedValueBase
	{
		public T Value
		{
			get
			{
				return (T)base.BoxedValue;
			}
			set
			{
				base.BoxedValue = value;
			}
		}

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

		public void AssignLocalValue(T value)
		{
			if (localIsOwner)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	internal class ConfigurationManagerAttributes
	{
		[UsedImplicitly]
		public bool? ReadOnly = false;
	}
	[PublicAPI]
	internal class ConfigSync
	{
		[HarmonyPatch(typeof(ZRpc), "HandlePackage")]
		private static class SnatchCurrentlyHandlingRPC
		{
			public static ZRpc? currentRpc;

			[HarmonyPrefix]
			private static void Prefix(ZRpc __instance)
			{
				currentRpc = __instance;
			}
		}

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

		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		private static class RegisterClientRPCPatch
		{
			[HarmonyPostfix]
			private static void Postfix(ZNet __instance, ZNetPeer peer)
			{
				if (__instance.IsServer())
				{
					return;
				}
				foreach (ConfigSync configSync in configSyncs)
				{
					peer.m_rpc.Register<ZPackage>(configSync.Name + " ConfigSync", (Action<ZRpc, ZPackage>)configSync.RPC_FromServerConfigSync);
				}
			}
		}

		private class ParsedConfigs
		{
			public readonly Dictionary<OwnConfigEntryBase, object?> configValues = new Dictionary<OwnConfigEntryBase, object>();

			public readonly Dictionary<CustomSyncedValueBase, object?> customValues = new Dictionary<CustomSyncedValueBase, object>();
		}

		[HarmonyPatch(typeof(ZNet), "Shutdown")]
		private class ResetConfigsOnShutdown
		{
			[HarmonyPostfix]
			private static void Postfix()
			{
				ProcessingServerUpdate = true;
				foreach (ConfigSync configSync in configSyncs)
				{
					configSync.resetConfigsFromServer();
					configSync.IsSourceOfTruth = true;
					configSync.InitialSyncDone = false;
				}
				ProcessingServerUpdate = false;
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		private class SendConfigsAfterLogin
		{
			private class BufferingSocket : ZPlayFabSocket, ISocket
			{
				public volatile bool finished = false;

				public volatile int versionMatchQueued = -1;

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

				public readonly ISocket Original;

				public BufferingSocket(ISocket original)
				{
					Original = original;
					((ZPlayFabSocket)this)..ctor();
				}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

				public void Send(ZPackage pkg)
				{
					//IL_0057: Unknown result type (might be due to invalid IL or missing references)
					//IL_005d: Expected O, but got Unknown
					int pos = pkg.GetPos();
					pkg.SetPos(0);
					int num = pkg.ReadInt();
					if ((num == StringExtensionMethods.GetStableHashCode("PeerInfo") || num == StringExtensionMethods.GetStableHashCode("RoutedRPC") || num == StringExtensionMethods.GetStableHashCode("ZDOData")) && !finished)
					{
						ZPackage val = new ZPackage(pkg.GetArray());
						val.SetPos(pos);
						Package.Add(val);
					}
					else
					{
						pkg.SetPos(pos);
						Original.Send(pkg);
					}
				}
			}

			[HarmonyPriority(800)]
			[HarmonyPrefix]
			private static void Prefix(ref Dictionary<Assembly, BufferingSocket>? __state, ZNet __instance, ZRpc rpc)
			{
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Invalid comparison between Unknown and I4
				if (!__instance.IsServer())
				{
					return;
				}
				BufferingSocket bufferingSocket = new BufferingSocket(rpc.GetSocket());
				AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc, bufferingSocket);
				object? obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
				ZNetPeer val = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
				if (val != null && (int)ZNet.m_onlineBackend > 0)
				{
					FieldInfo fieldInfo = AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket");
					object? value = fieldInfo.GetValue(val);
					ZPlayFabSocket val2 = (ZPlayFabSocket)((value is ZPlayFabSocket) ? value : null);
					if (val2 != null)
					{
						typeof(ZPlayFabSocket).GetField("m_remotePlayerId").SetValue(bufferingSocket, val2.m_remotePlayerId);
					}
					fieldInfo.SetValue(val, bufferingSocket);
				}
				if (__state == null)
				{
					__state = new Dictionary<Assembly, BufferingSocket>();
				}
				__state[Assembly.GetExecutingAssembly()] = bufferingSocket;
			}

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

		private class PackageEntry
		{
			public string section = null;

			public string key = null;

			public Type type = null;

			public object? value;
		}

		[HarmonyPatch(typeof(ConfigEntryBase), "GetSerializedValue")]
		private static class PreventSavingServerInfo
		{
			[HarmonyPrefix]
			private static bool Prefix(ConfigEntryBase __instance, ref string __result)
			{
				OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
				if (ownConfigEntryBase == null || isWritableConfig(ownConfigEntryBase))
				{
					return true;
				}
				__result = TomlTypeConverter.ConvertToString(ownConfigEntryBase.LocalBaseValue, __instance.SettingType);
				return false;
			}
		}

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

		private class InvalidDeserializationTypeException : Exception
		{
			public string expected = null;

			public string received = null;

			public string field = "";
		}

		public static bool ProcessingServerUpdate;

		public readonly string Name;

		public string? DisplayName;

		public string? CurrentVersion;

		public string? MinimumRequiredVersion;

		public bool ModRequired = false;

		private bool? forceConfigLocking;

		private bool isSourceOfTruth = true;

		private static readonly HashSet<ConfigSync> configSyncs;

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

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

		private static bool isServer;

		private static bool lockExempt;

		private OwnConfigEntryBase? lockedConfig = null;

		private const byte PARTIAL_CONFIGS = 1;

		private const byte FRAGMENTED_CONFIG = 2;

		private const byte COMPRESSED_CONFIG = 4;

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

		private readonly List<KeyValuePair<long, string>> cacheExpirations = new List<KeyValuePair<long, string>>();

		private static long packageCounter;

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

		public bool IsAdmin => lockExempt || isSourceOfTruth;

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

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


		public event Action<bool>? SourceOfTruthChanged;

		private event Action? lockedConfigChanged;

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

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

		public SyncedConfigEntry<T> AddConfigEntry<T>(ConfigEntry<T> configEntry)
		{
			ConfigEntry<T> configEntry2 = configEntry;
			OwnConfigEntryBase ownConfigEntryBase = configData((ConfigEntryBase)(object)configEntry2);
			SyncedConfigEntry<T> syncedEntry = ownConfigEntryBase as SyncedConfigEntry<T>;
			if (syncedEntry == null)
			{
				syncedEntry = new SyncedConfigEntry<T>(configEntry2);
				AccessTools.DeclaredField(typeof(ConfigDescription), "<Tags>k__BackingField").SetValue(((ConfigEntryBase)configEntry2).Description, new object[1]
				{
					new ConfigurationManagerAttributes()
				}.Concat(((ConfigEntryBase)configEntry2).Description.Tags ?? Array.Empty<object>()).Concat(new SyncedConfigEntry<T>[1] { syncedEntry }).ToArray());
				configEntry2.SettingChanged += delegate
				{
					if (!ProcessingServerUpdate && syncedEntry.SynchronizedConfig)
					{
						Broadcast(ZRoutedRpc.Everybody, (ConfigEntryBase)configEntry2);
					}
				};
				allConfigs.Add(syncedEntry);
			}
			return syncedEntry;
		}

		public SyncedConfigEntry<T> AddLockingConfigEntry<T>(ConfigEntry<T> lockingConfig) where T : IConvertible
		{
			if (lockedConfig != null)
			{
				throw new Exception("Cannot initialize locking ConfigEntry twice");
			}
			lockedConfig = AddConfigEntry<T>(lockingConfig);
			lockingConfig.SettingChanged += delegate
			{
				this.lockedConfigChanged?.Invoke();
			};
			return (SyncedConfigEntry<T>)lockedConfig;
		}

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

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

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

		private bool HandleConfigSyncRPC(long sender, ZPackage package, bool clientUpdate)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Expected O, but got Unknown
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Expected O, but got Unknown
			try
			{
				if (isServer && IsLocked)
				{
					ZRpc? currentRpc = SnatchCurrentlyHandlingRPC.currentRpc;
					object obj;
					if (currentRpc == null)
					{
						obj = null;
					}
					else
					{
						ISocket socket = currentRpc.GetSocket();
						obj = ((socket != null) ? socket.GetHostName() : null);
					}
					string text = (string)obj;
					if (text != null)
					{
						MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
						SyncedList val = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
						if (!(((object)methodInfo == null) ? val.Contains(text) : ((bool)methodInfo.Invoke(ZNet.instance, new object[2] { val, text }))))
						{
							return false;
						}
					}
				}
				cacheExpirations.RemoveAll(delegate(KeyValuePair<long, string> kv)
				{
					if (kv.Key < DateTimeOffset.Now.Ticks)
					{
						configValueCache.Remove(kv.Value);
						return true;
					}
					return false;
				});
				byte b = package.ReadByte();
				if ((b & 2u) != 0)
				{
					long num = package.ReadLong();
					string text2 = sender.ToString() + num;
					if (!configValueCache.TryGetValue(text2, out SortedDictionary<int, byte[]> value))
					{
						value = new SortedDictionary<int, byte[]>();
						configValueCache[text2] = value;
						cacheExpirations.Add(new KeyValuePair<long, string>(DateTimeOffset.Now.AddSeconds(60.0).Ticks, text2));
					}
					int key = package.ReadInt();
					int num2 = package.ReadInt();
					value.Add(key, package.ReadByteArray());
					if (value.Count < num2)
					{
						return false;
					}
					configValueCache.Remove(text2);
					package = new ZPackage(value.Values.SelectMany((byte[] a) => a).ToArray());
					b = package.ReadByte();
				}
				ProcessingServerUpdate = true;
				if ((b & 4u) != 0)
				{
					byte[] buffer = package.ReadByteArray();
					MemoryStream stream = new MemoryStream(buffer);
					MemoryStream memoryStream = new MemoryStream();
					using (DeflateStream deflateStream = new DeflateStream(stream, CompressionMode.Decompress))
					{
						deflateStream.CopyTo(memoryStream);
					}
					package = new ZPackage(memoryStream.ToArray());
					b = package.ReadByte();
				}
				if ((b & 1) == 0)
				{
					resetConfigsFromServer();
				}
				ParsedConfigs parsedConfigs = ReadConfigsFromPackage(package);
				ConfigFile val2 = null;
				bool saveOnConfigSet = false;
				foreach (KeyValuePair<OwnConfigEntryBase, object> configValue in parsedConfigs.configValues)
				{
					if (!isServer && configValue.Key.LocalBaseValue == null)
					{
						configValue.Key.LocalBaseValue = configValue.Key.BaseConfig.BoxedValue;
					}
					if (val2 == null)
					{
						val2 = configValue.Key.BaseConfig.ConfigFile;
						saveOnConfigSet = val2.SaveOnConfigSet;
						val2.SaveOnConfigSet = false;
					}
					configValue.Key.BaseConfig.BoxedValue = configValue.Value;
				}
				if (val2 != null)
				{
					val2.SaveOnConfigSet = saveOnConfigSet;
					val2.Save();
				}
				foreach (KeyValuePair<CustomSyncedValueBase, object> customValue in parsedConfigs.customValues)
				{
					if (!isServer)
					{
						CustomSyncedValueBase key2 = customValue.Key;
						if (key2.LocalBaseValue == null)
						{
							key2.LocalBaseValue = customValue.Key.BoxedValue;
						}
					}
					customValue.Key.BoxedValue = customValue.Value;
				}
				Debug.Log((object)string.Format("Received {0} configs and {1} custom values from {2} for mod {3}", parsedConfigs.configValues.Count, parsedConfigs.customValues.Count, (isServer || clientUpdate) ? $"client {sender}" : "the server", DisplayName ?? Name));
				if (!isServer)
				{
					serverLockedSettingChanged();
				}
				return true;
			}
			finally
			{
				ProcessingServerUpdate = false;
			}
		}

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

		private static bool isWritableConfig(OwnConfigEntryBase config)
		{
			OwnConfigEntryBase config2 = config;
			ConfigSync configSync = configSyncs.FirstOrDefault((ConfigSync cs) => cs.allConfigs.Contains(config2));
			if (configSync == null)
			{
				return true;
			}
			return configSync.IsSourceOfTruth || !config2.SynchronizedConfig || config2.LocalBaseValue == null || (!configSync.IsLocked && (config2 != configSync.lockedConfig || lockExempt));
		}

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

		private void resetConfigsFromServer()
		{
			ConfigFile val = null;
			bool saveOnConfigSet = false;
			foreach (OwnConfigEntryBase item in allConfigs.Where((OwnConfigEntryBase config) => config.LocalBaseValue != null))
			{
				if (val == null)
				{
					val = item.BaseConfig.ConfigFile;
					saveOnConfigSet = val.SaveOnConfigSet;
					val.SaveOnConfigSet = false;
				}
				item.BaseConfig.BoxedValue = item.LocalBaseValue;
				item.LocalBaseValue = null;
			}
			if (val != null)
			{
				val.SaveOnConfigSet = saveOnConfigSet;
			}
			foreach (CustomSyncedValueBase item2 in allCustomValues.Where((CustomSyncedValueBase config) => config.LocalBaseValue != null))
			{
				item2.BoxedValue = item2.LocalBaseValue;
				item2.LocalBaseValue = null;
			}
			lockedConfigChanged -= serverLockedSettingChanged;
			serverLockedSettingChanged();
		}

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

		private IEnumerator sendZPackage(long target, ZPackage package)
		{
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				return Enumerable.Empty<object>().GetEnumerator();
			}
			List<ZNetPeer> list = (List<ZNetPeer>)AccessTools.DeclaredField(typeof(ZRoutedRpc), "m_peers").GetValue(ZRoutedRpc.instance);
			if (target != ZRoutedRpc.Everybody)
			{
				list = list.Where((ZNetPeer p) => p.m_uid == target).ToList();
			}
			return sendZPackage(list, package);
		}

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

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

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

		private static OwnConfigEntryBase? configData(ConfigEntryBase config)
		{
			return config.Description.Tags?.OfType<OwnConfigEntryBase>().SingleOrDefault();
		}

		public static SyncedConfigEntry<T>? ConfigData<T>(ConfigEntry<T> config)
		{
			return ((ConfigEntryBase)config).Description.Tags?.OfType<SyncedConfigEntry<T>>().SingleOrDefault();
		}

		private static T configAttribute<T>(ConfigEntryBase config)
		{
			return config.Description.Tags.OfType<T>().First();
		}

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

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

		private static ZPackage ConfigsToPackage(IEnumerable<ConfigEntryBase>? configs = null, IEnumerable<CustomSyncedValueBase>? customValues = null, IEnumerable<PackageEntry>? packageEntries = null, bool partial = true)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			List<ConfigEntryBase> list = configs?.Where((ConfigEntryBase config) => configData(config).SynchronizedConfig).ToList() ?? new List<ConfigEntryBase>();
			List<CustomSyncedValueBase> list2 = customValues?.ToList() ?? new List<CustomSyncedValueBase>();
			ZPackage val = new ZPackage();
			val.Write((byte)(partial ? 1 : 0));
			val.Write(list.Count + list2.Count + (packageEntries?.Count() ?? 0));
			foreach (PackageEntry item in packageEntries ?? Array.Empty<PackageEntry>())
			{
				AddEntryToPackage(val, item);
			}
			foreach (CustomSyncedValueBase item2 in list2)
			{
				AddEntryToPackage(val, new PackageEntry
				{
					section = "Internal",
					key = item2.Identifier,
					type = item2.Type,
					value = item2.BoxedValue
				});
			}
			foreach (ConfigEntryBase item3 in list)
			{
				AddEntryToPackage(val, new PackageEntry
				{
					section = item3.Definition.Section,
					key = item3.Definition.Key,
					type = configType(item3),
					value = item3.BoxedValue
				});
			}
			return val;
		}

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

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

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

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

		private static readonly Dictionary<string, string> notProcessedNames;

		public string Name;

		private string? displayName;

		private string? currentVersion;

		private string? minimumRequiredVersion;

		public bool ModRequired = true;

		private string? ReceivedCurrentVersion;

		private string? ReceivedMinimumRequiredVersion;

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

		private ConfigSync? ConfigSync;

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

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

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

		private static void PatchServerSync()
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			Patches patchInfo = PatchProcessor.GetPatchInfo((MethodBase)AccessTools.DeclaredMethod(typeof(ZNet), "Awake", (Type[])null, (Type[])null));
			if (patchInfo != null && patchInfo.Postfixes.Count((Patch p) => p.PatchMethod.DeclaringType == typeof(ConfigSync.RegisterRPCPatch)) > 0)
			{
				return;
			}
			Harmony val = new Harmony("org.bepinex.helpers.ServerSync");
			foreach (Type item in from t in typeof(ConfigSync).GetNestedTypes(BindingFlags.NonPublic).Concat(new Type[1] { typeof(VersionCheck) })
				where t.IsClass
				select t)
			{
				val.PatchAll(item);
			}
		}

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

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

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

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

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

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

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

		private string Error(ZRpc? rpc = null)
		{
			return (rpc == null) ? ErrorClient() : ErrorServer(rpc);
		}

		private static VersionCheck[] GetFailedClient()
		{
			return versionChecks.Where((VersionCheck check) => !check.IsVersionOk()).ToArray();
		}

		private static VersionCheck[] GetFailedServer(ZRpc rpc)
		{
			ZRpc rpc2 = rpc;
			return versionChecks.Where((VersionCheck check) => check.ModRequired && !check.ValidatedClients.Contains(rpc2)).ToArray();
		}

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

		private static void DisconnectClient(ZRpc rpc)
		{
			rpc.Invoke("Error", new object[1] { 3 });
		}

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

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

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

		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		[HarmonyPrefix]
		private static void RegisterAndCheckVersion(ZNetPeer peer, ZNet __instance)
		{
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Expected O, but got Unknown
			notProcessedNames.Clear();
			IDictionary dictionary = (IDictionary)typeof(ZRpc).GetField("m_functions", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(peer.m_rpc);
			if (dictionary.Contains(StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")))
			{
				object obj = dictionary[StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")];
				Action<ZRpc, ZPackage> action = (Action<ZRpc, ZPackage>)obj.GetType().GetField("m_action", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(obj);
				peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)delegate(ZRpc rpc, ZPackage pkg)
				{
					CheckVersion(rpc, pkg, action);
				});
			}
			else
			{
				peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)CheckVersion);
			}
			foreach (VersionCheck versionCheck in versionChecks)
			{
				versionCheck.Initialize();
				if (versionCheck.ModRequired || __instance.IsServer())
				{
					Debug.Log((object)("Sending " + versionCheck.DisplayName + " version " + versionCheck.CurrentVersion + " and minimum version " + versionCheck.MinimumRequiredVersion + " to the " + (__instance.IsServer() ? "client" : "server") + "."));
					ZPackage val = new ZPackage();
					val.Write(versionCheck.Name);
					val.Write(versionCheck.MinimumRequiredVersion);
					val.Write(versionCheck.CurrentVersion);
					peer.m_rpc.Invoke("ServerSync VersionCheck", new object[1] { val });
				}
			}
		}

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

		[HarmonyPatch(typeof(FejdStartup), "ShowConnectError")]
		[HarmonyPostfix]
		private static void ShowConnectionError(FejdStartup __instance)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			if (!__instance.m_connectionFailedPanel.activeSelf || (int)ZNet.GetConnectionStatus() != 3)
			{
				return;
			}
			bool flag = false;
			VersionCheck[] failedClient = GetFailedClient();
			if (failedClient.Length != 0)
			{
				string text = string.Join("\n", failedClient.Select((VersionCheck check) => check.Error()));
				TMP_Text connectionFailedError = __instance.m_connectionFailedError;
				connectionFailedError.text = connectionFailedError.text + "\n" + text;
				flag = true;
			}
			foreach (KeyValuePair<string, string> item in notProcessedNames.OrderBy<KeyValuePair<string, string>, string>((KeyValuePair<string, string> kv) => kv.Key))
			{
				if (!__instance.m_connectionFailedError.text.Contains(item.Key))
				{
					TMP_Text connectionFailedError2 = __instance.m_connectionFailedError;
					connectionFailedError2.text = connectionFailedError2.text + "\nServer expects you to have " + item.Key + " (Version: " + item.Value + ") installed.";
					flag = true;
				}
			}
			if (flag)
			{
				RectTransform component = ((Component)__instance.m_connectionFailedPanel.transform.Find("Image")).GetComponent<RectTransform>();
				Vector2 sizeDelta = component.sizeDelta;
				sizeDelta.x = 675f;
				component.sizeDelta = sizeDelta;
				__instance.m_connectionFailedError.ForceMeshUpdate(false, false);
				float num = __instance.m_connectionFailedError.renderedHeight + 105f;
				RectTransform component2 = ((Component)((Component)component).transform.Find("ButtonOk")).GetComponent<RectTransform>();
				component2.anchoredPosition = new Vector2(component2.anchoredPosition.x, component2.anchoredPosition.y - (num - component.sizeDelta.y) / 2f);
				sizeDelta = component.sizeDelta;
				sizeDelta.y = num;
				component.sizeDelta = sizeDelta;
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
}
namespace YamlDotNet
{
	internal sealed class CultureInfoAdapter : CultureInfo
	{
		private readonly IFormatProvider provider;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		internal INamingConvention enumNamingConvention = 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;

		internal YamlFormatter yamlFormatter = YamlFormatter.Default;

		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 WithEnumNamingConvention(INamingConvention enumNamingConvention)
		{
			this.enumNamingConvention = enumNamingConvention;
			return Self;
		}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		public TBuilder WithYamlFormatter(YamlFormatter formatter)
		{
			yamlFormatter = formatter ?? throw new ArgumentNullException("formatter");
			return Self;
		}

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

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

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

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

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

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

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

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

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

		public object? Deserialize(IParser parser)
		{
			return Deserialize<object>(parser);
		}

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

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

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

		private readonly LazyComponentRegistrationList<Nothing, INodeDeserializer> nodeDeserializerFactories;

		private readonly LazyComponentRegistrationList<Nothing, INodeTypeResolver> nodeTypeResolverFactories;

		private readonly Dictionary<TagName, Type> tagMappings;

		private readonly Dictionary<Type, Type> typeMappings;

		private readonly ITypeConverter typeConverter;

		private bool ignoreUnmatched;

		private bool duplicateKeyChecking;

		private bool attemptUnknownTypeDeserialization;

		private bool enforceNullability;

		private bool caseInsensitivePropertyMatching;

		private bool enforceRequiredProperties;

		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, BuildTypeInspector(), yamlFormatter, enumNamingConvention)
				},
				{
					typeof(ArrayNodeDeserializer),
					(Nothing _) => new ArrayNodeDeserializer(enumNamingConvention, BuildTypeInspector())
				},
				{
					typeof(DictionaryNodeDeserializer),
					(Nothing _) => new DictionaryNodeDeserializer(objectFactory.Value, duplicateKeyChecking)
				},
				{
					typeof(CollectionNodeDeserializer),
					(Nothing _) => new CollectionNodeDeserializer(objectFactory.Value, enumNamingConvention, BuildTypeInspector())
				},
				{
					typeof(EnumerableNodeDeserializer),
					(Nothing _) => new EnumerableNodeDeserializer()
				},
				{
					typeof(ObjectNodeDeserializer),
					(Nothing _) => new ObjectNodeDeserializer(objectFactory.Value, BuildTypeInspector(), ignoreUnmatched, duplicateKeyChecking, typeConverter, enumNamingConvention, enforceNullability, caseInsensitivePropertyMatching, enforceRequiredProperties, BuildTypeConverters())
				},
				{
					typeof(FsharpListNodeDeserializer),
					(Nothing _) => new FsharpListNodeDeserializer(BuildTypeInspector(), enumNamingConvention)
				}
			};
			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();
		}

		public 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)
		{
			IObjectFactory objectFactory2 = objectFactory;
			if (objectFactory2 == null)
			{
				throw new ArgumentNullException("objectFactory");
			}
			this.objectFactory = new Lazy<IObjectFactory>(() => objectFactory2, isThreadSafe: true);
			return this;
		}

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

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

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

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

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

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

		public DeserializerBuilder 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)
		{
			INodeTypeResolver nodeTypeResolver2 = nodeTypeResolver;
			if (nodeTypeResolver2 == null)
			{
				throw new ArgumentNullException("nodeTypeResolver");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateRegistrationLocationSelector(nodeTypeResolver2.GetType(), (Nothing _) => nodeTypeResolver2));
			return this;
		}

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

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

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

		public DeserializerBuilder WithEnforceRequiredMembers()
		{
			enforceRequiredProperties = true;
			return this;
		}

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

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

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

		public DeserializerBuilder WithTypeMapping<TInterface, TConcrete>() where TConcrete : TInterface
		{
			Type typeFromHandle = typeof(TInterface);
			Type typeFromHandle2 = typeof(TConcrete);
			if (!typeFromHandle.IsAssignableFrom(typeFromHandle2))
			{
				throw new InvalidOperationException("The type '" + typeFromHandle2.Name + "' does not implement interface '" + typeFromHandle.Name + "'.");
			}
			if (!DictionaryExtensions.TryAdd(typeMappings, typeFromHandle, typeFromHandle2))
			{
				typeMappings[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()
		{
			if (FsharpHelper.Instance == null)
			{
				FsharpHelper.Instance = new DefaultFsharpHelper();
			}
			return Deserializer.FromValueDeserializer(BuildValueDeserializer());
		}

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

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

		public IEventEmitter EventEmitter { get; private set; }

		public ObjectSerializer NestedObjectSerializer { get; private set; }

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

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

		public T GetPreProcessingPhaseObjectGraphVisitor<T>() where T : IObjectGraphVisitor<Nothing>
		{
			return preProcessingPhaseVisitors.OfType<T>().Single();
		}
	}
	internal abstract class EventInfo
	{
		public IObjectDescriptor Source { get; }

		protected EventInfo(IObjectDescriptor source)
		{
			Source = source ?? throw new ArgumentNullException("source");
		}
	}
	internal class AliasEventInfo : EventInfo
	{
		public AnchorName Alias { get; }

		public bool NeedsExpansion { get; set; }

		public AliasEventInfo(IObjectDescriptor source, AnchorName alias)
			: base(source)
		{
			if (alias.IsEmpty)
			{
				throw new ArgumentNullException("alias");
			}
			Alias = alias;
		}
	}
	internal class ObjectEventInfo : EventInfo
	{
		public AnchorName Anchor { get; set; }

		public TagName Tag { get; set; }

		protected ObjectEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class ScalarEventInfo : ObjectEventInfo
	{
		public string RenderedValue { get; set; }

		public ScalarStyle Style { get; set; }

		public bool IsPlainImplicit { get; set; }

		public bool IsQuotedImplicit { get; set; }

		public ScalarEventInfo(IObjectDescriptor source)
			: base(source)
		{
			Style = source.ScalarStyle;
			RenderedValue = string.Empty;
		}
	}
	internal sealed class MappingStartEventInfo : ObjectEventInfo
	{
		public bool IsImplicit { get; set; }

		public MappingStyle Style { get; set; }

		public MappingStartEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class MappingEndEventInfo : EventInfo
	{
		public MappingEndEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class SequenceStartEventInfo : ObjectEventInfo
	{
		public bool IsImplicit { get; set; }

		public SequenceStyle Style { get; set; }

		public SequenceStartEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class SequenceEndEventInfo : EventInfo
	{
		public SequenceEndEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal interface IAliasProvider
	{
		AnchorName GetAlias(object target);
	}
	internal interface IDeserializer
	{
		T Deserialize<T>(string input);

		T Deserialize<T>(TextReader input);

		T Deserialize<T>(IParser parser);

		object? Deserialize(string input);

		object? Deserialize(TextReader input);

		object? Deserialize(IParser parser);

		object? Deserialize(string input, Type type);

		object? Deserialize(TextReader input, Type type);

		object? Deserialize(IParser parser, Type type);
	}
	internal interface IEventEmitter
	{
		void Emit(AliasEventInfo eventInfo, IEmitter emitter);

		void Emit(ScalarEventInfo eventInfo, IEmitter emitter);

		void Emit(MappingStartEventInfo eventInfo, IEmitter emitter);

		void Emit(MappingEndEventInfo eventInfo, IEmitter emitter);

		void Emit(SequenceStartEventInfo eventInfo, IEmitter emitter);

		void Emit(SequenceEndEventInfo eventInfo, IEmitter emitter);
	}
	internal interface INamingConvention
	{
		string Apply(string value);

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

		object? Read(string name, object target);
	}
	internal interface IObjectDescriptor
	{
		object? Value { get; }

		Type Type { get; }

		Type StaticType { get; }

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

		object? CreatePrimitive(Type type);

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

		Type GetValueType(Type type);

		void ExecuteOnDeserializing(object value);

		void ExecuteOnDeserialized(object value);

		void ExecuteOnSerializing(object value);

		void ExecuteOnSerialized(object value);
	}
	internal interface IObjectGraphTraversalStrategy
	{
		void Traverse<TContext>(IObjectDescriptor graph, IObjectGraphVisitor<TContext> visitor, TContext context, ObjectSerializer serializer);
	}
	internal interface IObjectGraphVisitor<TContext>
	{
		bool Enter(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, TContext context, ObjectSerializer serializer);

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

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

		void VisitScalar(IObjectDescriptor scalar, TContext context, ObjectSerializer serializer);

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

		void VisitMappingEnd(IObjectDescriptor mapping, TContext context, ObjectSerializer serializer);

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

		void VisitSequenceEnd(IObjectDescriptor sequence, TContext context, ObjectSerializer serializer);
	}
	internal interface IPropertyDescriptor
	{
		string Name { get; }

		bool AllowNulls { get; }

		bool CanWrite { get; }

		Type Type { get; }

		Type? TypeOverride { get; set; }

		int Order { get; set; }

		ScalarStyle ScalarStyle { get; set; }

		bool Required { get; }

		Type? ConverterType { get; }

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

		IObjectDescriptor Read(object target);

		void Write(object target, object? value);
	}
	internal interface IRegistrationLocationSelectionSyntax<TBaseRegistrationType>
	{
		void InsteadOf<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;

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

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

		void OnTop();

		void OnBottom();
	}
	internal interface ITrackingRegistrationLocationSelectionSyntax<TBaseRegistrationType>
	{
		void InsteadOf<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;
	}
	internal interface ISerializer
	{
		string Serialize(object? graph);

		string Serialize(object? graph, Type type);

		void Serialize(TextWriter writer, object? graph);

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

		void Serialize(IEmitter emitter, object? graph);

		void Serialize(IEmitter emitter, object? graph, Type type);
	}
	internal interface ITypeInspector
	{
		IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container);

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

		string GetEnumName(Type enumType, string name);

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

		void Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer);
	}
	internal delegate object? ObjectDeserializer(Type type);
	internal delegate void ObjectSerializer(object? value, Type? type = null);
	[Obsolete("Please use IYamlConvertible instead")]
	internal interface IYamlSerializable
	{
		void ReadYaml(IParser parser);

		void WriteYaml(IEmitter emitter);
	}
	internal interface IYamlTypeConverter
	{
		bool Accepts(Type type);

		object? ReadYaml(IParser parser, Type type, ObjectDeserializer rootDeserializer);

		void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer);
	}
	internal sealed class LazyComponentRegistrationList<TArgument, TComponent> : IEnumerable<Func<TArgument, TComponent>>, IEnumerable
	{
		public sealed class LazyComponentRegistration
		{
			public readonly Type ComponentType;

			public readonly Func<TArgument, TComponent> Factory;

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

		public sealed class TrackingLazyComponentRegistration
		{
			public readonly Type ComponentType;

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

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

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

			private readonly LazyComponentRegistration newRegistration;

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

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

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

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

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

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

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

			private readonly TrackingLazyComponentRegistration newRegistration;

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

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

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

		public int Count => entries.Count;

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

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

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

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

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

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

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

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

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

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

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

		private int EnsureRegistrationExists<TRegistrationType>()
		{
			int num = IndexOfRegistration(typeof(TRegistrationType));
			if (num == -1)
			{
				throw new InvalidOperationException("A component of type '" + typeof(TRegistrationType).FullName + "' has not been registered.");
			}
			return num;
		}
	}
	internal static class LazyComponentRegistrationListExtensions
	{
		public static TComponent BuildComponentChain<TComponent>(this LazyComponentRegistrationList<TComponent, TComponent> registrations, TComponent innerComponent)
		{
			return registrations.InReverseOrder.Aggregate(innerComponent, (TComponent inner, Func<TComponent, TComponent> factory) => factory(inner));
		}

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

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

		public static List<TComponent> BuildComponentList<TArgument, TComponent>(this LazyComponentRegistrationList<TArgument, TComponent> registrations, TArgument argument)
		{
			TArgument argument2 = argument;
			return registrations.Select((Func<TArgument, TComponent> factory) => factory(argument2)).ToList();
		}
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	internal struct Nothing
	{
	}
	internal sealed class ObjectDescriptor : IObjectDescriptor
	{
		public object? Value { get; private set; }

		public Type Type { get; private set; }

		public Type StaticType { get; private set; }

		public ScalarStyle ScalarStyle { get; private set; }

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

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

		public bool AllowNulls => baseDescriptor.AllowNulls;

		public string Name { get; set; }

		public bool Required => baseDescriptor.Required;

		public Type Type => baseDescriptor.Type;

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

		public Type? ConverterType => baseDescriptor.ConverterType;

		public int Order { get; set; }

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

		public bool CanWrite => baseDescriptor.CanWrite;

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

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

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

		public IObjectDescriptor Read(object target)
		{
			return baseDescriptor.Read(target);
		}
	}
	internal sealed class Serializer : ISerializer
	{
		private readonly IValueSerializer valueSerializer;

		private readonly EmitterSettings emitterSettings;

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

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

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

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

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

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

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

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

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

		private void EmitDocument(IEmitter emitter, object? graph, Type? type)
		{
			emitter.Emit(new YamlDotNet.Core.Events.StreamStart());
			emitter.Emit(new YamlDotNet.Core.Events.DocumentStart());
			valueSerializer.SerializeValue(emitter, graph, type);
			emitter.Emit(new YamlDotNet.Core.Events.DocumentEnd(isImplicit: true));
			emitter.Emit(new YamlDotNet.Core.Events.StreamEnd());
		}
	}
	internal sealed class SerializerBuilder : BuilderSkeleton<SerializerBuilder>
	{
		private class ValueSerializer : IValueSerializer
		{
			private readonly IObjectGraphTraversalStrategy traversalStrategy;

			private readonly IEventEmitter eventEmitter;

			private readonly IEnumerable<IYamlTypeConverter> typeConverters;

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

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

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

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

		private ObjectGraphTraversalStrategyFactory objectGraphTraversalStrategyFactory;

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

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

		private readonly LazyComponentRegistrationList<IEventEmitter, IEventEmitter> eventEmitterFactories;

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

		private readonly IObjectFactory objectFactory;

		private int maximumRecursion = 50;

		private EmitterSettings emitterSettings = EmitterSettings.Default;

		private DefaultValuesHandling defaultValuesHandlingConfiguration;

		private ScalarStyle defaultScalarStyle;

		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, tagMappings, quoteNecessaryStrings, quoteYaml1_1Strings, defaultScalarStyle, yamlFormatter, enumNamingConvention, BuildTypeInspector())
			} };
			objectFactory = new DefaultObjectFactory();
			objectGraphTraversalStrategyFactory = (ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion) => new FullObjectGraphTraversalStrategy(typeInspector, typeResolver, maximumRecursion, namingConvention, objectFactory);
		}

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

		public SerializerBuilder WithDefaultScalarStyle(ScalarStyle style)
		{
			defaultScalarStyle = style;
			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<TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory) where TEventEmitter : IEventEmitter
		{
			return WithEventEmitter(eventEmitterFactory, delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> w)
			{
				w.OnTop();
			});
		}

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

		public SerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory, Action<IRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			Func<IEventEmitter, TEventEmitter> eventEmitterFactory2 = eventEmitterFactory;
			return WithEventEmitter((IEventEmitter e, ITypeInspector _) => eventEmitterFactory2(e), where);
		}

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

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

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

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

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

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

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

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

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

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

		public SerializerBuilder JsonCompatible()
		{
			emitterSettings = emitterSettings.WithMaxSimpleKeyLength(int.MaxValue).WithoutAnchorName().WithUtf16SurrogatePairs();
			return WithTypeConverter(new YamlDotNet.Serialization.Converters.GuidConverter(jsonCompatible: true), delegate(IRegistrationLocationSelectionSyntax<IYamlTypeConverter> w)
			{
				w.InsteadOf<YamlDotNet.Serialization.Converters.GuidConverter>();
			}).WithTypeConverter(new DateTime8601Converter(ScalarStyle.DoubleQuoted)).WithEventEmitter((IEventEmitter inner) => new JsonEventEmitter(inner, yamlFormatter, enumNamingConvention, BuildTypeInspector()), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
			{
				loc.InsteadOf<TypeAssigningEventEmitter>();
			});
		}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		public ISerializer Build()
		{
			if (FsharpHelper.Instance == null)
			{
				FsharpHelper.Instance = new DefaultFsharpHelper();
			}
			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());
		}

		public 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; }
	}
	internal abstract class StaticBuilderSkeleton<TBuilder> where TBuilder : StaticBuilderSkeleton<TBuilder>
	{
		internal INamingConvention namingConvention = NullNamingConvention.Instance;

		internal INamingConvention enumNamingConvention = NullNamingConvention.Instance;

		internal ITypeResolver typeResolver;

		internal readonly LazyComponentRegistrationList<Nothing, IYamlTypeConverter> typeConverterFactories;

		internal readonly LazyComponentRegistrationList<ITypeInspector, ITypeInspector> typeInspectorFactories;

		internal bool includeNonPublicProperties;

		internal Settings settings;

		internal YamlFormatter yamlFormatter = YamlFormatter.Default;

		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 WithEnumNamingConvention(INamingConvention enumNamingConvention)
		{
			this.enumNamingConvention = enumNamingConvention ?? throw new ArgumentNullException("enumNamingConvention");
			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)
		{
			IYamlTypeConverter typeConverter2 = typeConverter;
			if (typeConverter2 == null)
			{
				throw new ArgumentNullException("typeConverter");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateRegistrationLocationSelector(typeConverter2.GetType(), (Nothing _) => typeConverter2));
			return Self;
		}

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

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

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

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

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

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

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

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

		public TBuilder WithYamlFormatter(YamlFormatter formatter)
		{
			yamlFormatter = formatter ?? throw new ArgumentNullException("formatter");
			return Self;
		}

		protected IEnumerable<IYamlTypeConverter> BuildTypeConverters()
		{
			return typeConverterFactories.BuildComponentList();
		}
	}
	internal abstract class StaticContext
	{
		public virtual bool IsKnownType(Type type)
		{
			throw new NotImplementedException();
		}

		public virtual ITypeResolver GetTypeResolver()
		{
			throw new NotImplementedException();
		}

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

		public virtual ITypeInspector GetTypeInspector()
		{
			throw new NotImplementedException();
		}
	}
	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;

		private bool enforceNullability;

		private bool caseInsensitivePropertyMatching;

		protected override StaticDeserializerBuilder Self => this;

		public StaticDeserializerBuilder(StaticContext context)
			: base(context.GetTypeResolver())
		{
			this.context = context;
			factory = context.GetFactory();
			typeMappings = new Dictionary<Type, Type>();
			tagMappings = new Dictionary<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, BuildTypeInspector(), yamlFormatter, enumNamingConvention)
				},
				{
					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, enumNamingConvention, enforceNullability, caseInsensitivePropertyMatching, enforceRequiredProperties: false, BuildTypeConverters())
				}
			};
			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();
		}

		public 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)
		{
			INodeDeserializer nodeDeserializer2 = nodeDeserializer;
			if (nodeDeserializer2 == null)
			{
				throw new ArgumentNullException("nodeDeserializer");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateRegistrationLocationSelector(nodeDeserializer2.GetType(), (Nothing _) => nodeDeserializer2));
			return this;
		}

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

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

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

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

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

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

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

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

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

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

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

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

		public StaticDeserializerBuilder WithTypeMapping<TInterface, TConcrete>() where TConcrete : TInterface
		{
			Type typeFromHandle = typeof(TInterface);
			Type typeFromHandle2 = typeof(TConcrete);
			if (!typeFromHandle.IsAssignableFrom(typeFromHandle2))
			{
				throw new InvalidOperationException("The type '" + typeFromHandle2.Name + "' does not implement interface '" + typeFromHandle.Name + "'.");
			}
			typeMappings[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, enumNamingConvention, BuildTypeInspector()));
		}
	}
	internal sealed class StaticSerializerBuilder : StaticBuilderSkeleton<StaticSerializerBuilder>
	{
		private class ValueSerializer : IValueSerializer
		{
			private readonly IObjectGraphTraversalStrategy traversalStrategy;

			private readonly IEventEmitter eventEmitter;

			private readonly IEnumerable<IYamlTypeConverter> typeConverters;

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

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

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

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

		private int maximumRecursion = 50;

		private EmitterSettings emitterSettings = EmitterSettings.Default;

		private DefaultValuesHandling defaultValuesHandlingConfiguration;

		private bool quoteNecessaryStrings;

		private bool quoteYaml1_1Strings;

		private ScalarStyle defaultScalarStyle;

		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, tagMappings, quoteNecessaryStrings, quoteYaml1_1Strings, defaultScalarStyle, yamlFormatter, enumNamingConvention, BuildTypeInspector())
			} };
			objectGraphTraversalStrategyFactory = (ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion) => new FullObjectGraphTraversalStrategy(typeInspector, typeResolver, maximumRecursion, namingConvention, factory);
		}

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

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

		public StaticSerializerBuilder WithDefaultScalarStyle(ScalarStyle style)
		{
			defaultScalarStyle = style;
			return this;
		}

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

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

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

		public StaticSerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory, Action<IRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			Func<IEventEmitter, TEventEmitter> eventEmitterFactory2 = eventEmitterFactory;
			return WithEventEmitter((IEventEmitter e, ITypeInspector _) => eventEmitterFactory2(e), where);
		}

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

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

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

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

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

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

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

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

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

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

		public StaticSerializerBuilder JsonCompatible()
		{
			emitterSettings = emitterSettings.WithMaxSimpleKeyLength(int.MaxValue).WithoutAnchorName().WithUtf16SurrogatePairs();
			return WithTypeConverter(new YamlDotNet.Serialization.Converters.GuidConverter(jsonCompatible: true), delegate(IRegistrationLocationSelectionSyntax<IYamlTypeConverter> w)
			{
				w.InsteadOf<YamlDotNet.Serialization.Converters.GuidConverter>();
			}).WithTypeConverter(new DateTime8601Converter(ScalarStyle.DoubleQuoted)).WithEventEmitter((IEventEmitter inner) => new JsonEventEmitter(inner, yamlFormatter, enumNamingConvention, BuildTypeInspector()), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
			{
				loc.InsteadOf<TypeAssigningEventEmitter>();
			});
		}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		public ITypeInspector BuildTypeInspector()
		{
			ITypeInspector typeInspector = context.GetTypeInspector();
			return typeInspectorFactories.BuildComponentChain(typeInspector);
		}
	}
	internal sealed class StreamFragment : IYamlConvertible
	{
		private readonly List<ParsingEvent> events = new List<ParsingEvent>();

		public IList<ParsingEvent> Events => events;

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

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

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

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

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

		internal Type? GetMapping(string tag)
		{
			if (!mappings.TryGetValue(tag, out Type value))
			{
				return null;
			}
			return value;
		}
	}
	internal sealed class YamlAttributeOverrides
	{
		private readonly struct AttributeKey
		{
			public readonly Type AttributeType;

			public readonly string PropertyName;

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

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

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

		private sealed class AttributeMapping
		{
			public readonly Type RegisteredType;

			public readonly Attribute Attribute;

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

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

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

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

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

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

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

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

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

			private readonly YamlAttributeOverrides overrides;

			private readonly Type classType;

			public string Name => baseDescriptor.Name;

			public bool Required => baseDescriptor.Required;

			public bool AllowNulls => baseDescriptor.AllowNulls;

			public bool CanWrite => baseDescriptor.CanWrite;

			public Type Type => baseDescriptor.Type;

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

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

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

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

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

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

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

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

		private readonly ITypeInspector innerTypeDescriptor;

		private readonly YamlAttributeOverrides overrides;

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

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

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

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

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

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

		public YamlConverterAttribute(Type converterType)
		{
			ConverterType = converterType;
		}
	}
	internal class YamlFormatter
	{
		public static YamlFormatter Default { get; } = new YamlFormatter();


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


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


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


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

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

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

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

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

		public string FormatTimeSpan(object timeSpan)
		{
			return ((TimeSpan)timeSpan).ToString();
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
	internal sealed class YamlIgnoreAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
	internal sealed class YamlMemberAttribute : Attribute
	{
		private DefaultValuesHandling? defaultValuesHandling;

		public string? Description { get; set; }

		public Type? SerializeAs { get; set; }

		public int Order { get; set; }

		public string? Alias { get; set; }

		public bool ApplyNamingConventions { get; set; }

		public ScalarStyle ScalarStyle { get; set; }

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

		public bool IsDefaultValuesHandlingSpecified => defaultValuesHandling.HasValue;

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

		public YamlMemberAttribute(Type serializeAs)
			: this()
		{
			SerializeAs = serializeAs ?? throw new ArgumentNullException("serializeAs");
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum, Inherited = false, AllowMultiple = true)]
	internal sealed class YamlSerializableAttribute : Attribute
	{
		public YamlSerializableAttribute()
		{
		}

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

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

			public readonly YamlDotNet.Core.Events.AnchorAlias? Alias;

			public bool HasValue { get; private set; }

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

			public event Action<object?>? ValueAvailable;

			public ValuePromise(YamlDotNet.Core.Events.AnchorAlias alias)
			{
				Alias = alias;
			}

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

		private readonly IValueDeserializer innerDeserializer;

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

		public object? DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
		{
			if (parser.TryConsume<YamlDotNet.Core.Events.AnchorAlias>(out var @event))
			{
				AliasState aliasState = state.Get<AliasState>();
				if (!aliasState.TryGetValue(@event.Value, out ValuePromise 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 aliasState2 = state.Get<AliasState>();
				if (!aliasState2.ContainsKey(anchorName))
				{
					aliasState2[anchorName] = new ValuePromise(new YamlDotNet.Core.Events.AnchorAlias(anchorName));
				}
			}
			object obj = innerDeserializer.DeserializeValue(parser, expectedType, state, nestedObjectDeserializer);
			if (!anchorName.IsEmpty)
			{
				AliasState aliasState3 = state.Get<AliasState>();
				if (!aliasState3.TryGetValue(anchorName, out ValuePromise value2))
				{
					aliasState3.Add(anchorName, new ValuePromise(obj));
				}
				else if (!value2.HasValue)
				{
					value2.Value = obj;
				}
				else
				{
					aliasState3[anchorName] = new ValuePromise(obj);
				}
			}
			return obj;
		}
	}
	internal sealed class NodeValueDeserializer : IValueDeserializer
	{
		private readonly IList<INodeDeserializer> deserializers;

		private readonly IList<INodeTypeResolver> typeResolvers;

		private readonly ITypeConverter typeConverter;

		private readonly INamingConvention enumNamingConvention;

		private readonly ITypeInspector typeInspector;

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

		public object? DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
		{
			IParser parser2 = parser;
			SerializerState state2 = state;
			IValueDeserializer nestedObjectDeserializer2 = nestedObjectDeserializer;
			parser2.Accept<NodeEvent>(out var @event);
			Type typeFromEvent = GetTypeFromEvent(@event, expectedType);
			ObjectDeserializer rootDeserializer = (Type x) => DeserializeValue(parser2, x, state2, nestedObjectDeserializer2);
			Mark start;
			Mark end;
			try
			{
				foreach (INodeDeserializer deserializer in deserializers)
				{
					if (deserializer.Deserialize(parser2, typeFromEvent, (IParser r, Type t) => nestedObjectDeserializer2.DeserializeValue(r, t, state2, nestedObjectDeserializer2), out object value, rootDeserializer))
					{
						return typeConverter.ChangeType(value, expectedType, enumNamingConvention, typeInspector);
					}
				}
			}
			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(NodeEvent? nodeEvent, Type currentType)
		{
			foreach (INodeTypeResolver typeResolver in typeResolvers)
			{
				if (typeResolver.Resolve(nodeEvent, ref currentType))
				{
					break;
				}
			}
			return currentType;
		}
	}
}
namespace YamlDotNet.Serialization.Utilities
{
	internal interface IPostDeserializationCallback
	{
		void OnDeserialization();
	}
	internal interface ITypeConverter
	{
		object? ChangeType(object? value, Type expectedType, INamingConvention enumNamingConvention, ITypeInspector typeInspector);
	}
	internal class NullTypeConverter : ITypeConverter
	{
		public object? ChangeType(object? value, Type expectedType, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			return value;
		}
	}
	internal sealed class ObjectAnchorCollection
	{
		private readonly Dictionary<string, object> objectsByAnchor = new Dictionary<string, object>();

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

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

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

		public bool TryGetAnchor(object @object, [MaybeNullWhen(false)] out string? anchor)
		{
			return anchorsByObject.TryGetValue(@object, out anchor);
		}
	}
	internal class ReflectionTypeConverter : ITypeConverter
	{
		public object? ChangeType(object? value, Type expectedType, ITypeInspector typeInspector)
		{
			return ChangeType(value, expectedType, NullNamingConvention.Instance, typeInspector);
		}

		public object? ChangeType(object? value, Type expectedType, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			return TypeConverter.ChangeType(value, expectedType, enumNamingConvention, typeInspector);
		}
	}
	internal sealed class SerializerState : IDisposable
	{
		private readonly Dictionary<Type, object> items = new Dictionary<Type, object>();

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

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

		public void Dispose()
		{
			foreach (IDisposable item in items.Values.OfType<IDisposable>())
			{
				item.Dispose();
			}
		}
	}
	internal static class StringExtensions
	{
		private static string ToCamelOrPascalCase(string str, Func<char, char> firstLetterTransform)
		{
			string text = Regex.Replace(str, "([_\\-])(?<char>[a-z])", (Match match) => match.Groups["char"].Value.ToUpperInvariant(), RegexOptions.IgnoreCase);
			return firstLetterTransform(text[0]) + text.Substring(1);
		}

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

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

		public static string FromCamelCase(this string str, string separator)
		{
			string separator2 = separator;
			str = char.ToLower(str[0], CultureInfo.InvariantCulture) + str.Substring(1);
			str = Regex.Replace(str.ToCamelCase(), "(?<char>[A-Z])", (Match match) => separator2 + match.Groups["char"].Value.ToLowerInvariant());
			return str;
		}
	}
	internal static class TypeConverter
	{
		public static T ChangeType<T>(object? value, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			return (T)ChangeType(value, typeof(T), enumNamingConvention, typeInspector);
		}

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

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

		public static object? ChangeType(object? value, Type destinationType, CultureInfo culture, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			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())
			{
				Type genericTypeDefinition = destinationType.GetGenericTypeDefinition();
				if (genericTypeDefinition == typeof(Nullable<>) || FsharpHelper.IsOptionType(genericTypeDefinition))
				{
					Type destinationType2 = destinationType.GetGenericArguments()[0];
					object obj = ChangeType(value, destinationType2, culture, enumNamingConvention, typeInspector);
					return Activator.CreateInstance(destinationType, obj);
				}
			}
			if (destinationType.IsEnum())
			{
				object result = value;
				if (value is string value2)
				{
					string name = enumNamingConvention.Reverse(value2);
					name = typeInspector.GetEnumName(destinationType, name);
					result = Enum.Parse(destinationType, name, ignoreCase: true);
				}
				return result;
			}
			if (destinationType == typeof(bool))
			{
				if ("0".Equals(value))
				{
					return false;
				}
				if ("1".Equals(value))
				{
					return true;
				}
			}
			System.ComponentModel.TypeConverter converter = TypeDescriptor.GetConverter(type);
			if (converter != null && converter.CanConvertTo(destinationType))
			{
				return converter.ConvertTo(null, culture, value, destinationType);
			}
			System.ComponentModel.TypeConverter converter2 = TypeDescriptor.GetConverter(destinationType);
			if (converter2 != null && converter2.CanConvertFrom(type))
			{
				return converter2.ConvertFrom(null, culture, value);
			}
			Type[] array = new Type[2] { type, destinationType };
			foreach (Type type2 in array)
			{
				foreach (MethodInfo publicStaticMethod2 in type2.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.InnerException;
						}
					}
				}
			}
			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.InnerException;
				}
			}
			if (destinationType == typeof(TimeSpan))
			{
				return TimeSpan.Parse((string)ChangeType(value, typeof(string), CultureInfo.InvariantCulture, enumNamingConvention, typeInspector), CultureInfo.InvariantCulture);
			}
			return Convert.ChangeType(value, destinationType, CultureInfo.InvariantCulture);
		}

		public static void RegisterTypeConverter<TConvertible, TConverter>() where TConverter : System.ComponentModel.TypeConverter
		{
			if (!TypeDescriptor.GetAttributes(typeof(TConvertible)).OfType<TypeConverterAttribute>().Any((TypeConverterAttribute a) => a.ConverterTypeName == typeof(TConverter).AssemblyQualifiedName))
			{
				TypeDescriptor.AddAttributes(typeof(TConvertible), new TypeConverterAttribute(typeof(TConverter)));
			}
		}
	}
	internal sealed class TypeConverterCache
	{
		private readonly IYamlTypeConverter[] typeConverters;

		private readonly ConcurrentDictionary<Type, (bool HasMatch, IYamlTypeConverter? TypeConverter)> cache = new ConcurrentDictionary<Type, (bool, IYamlTypeConverter)>();

		public TypeConverterCache(IEnumerable<IYamlTypeConverter>? typeConverters)
			: this(typeConverters?.ToArray() ?? Array.Empty<IYamlTypeConverter>())
		{
		}

		public TypeConverterCache(IYamlTypeConverter[] typeConverters)
		{
			this.typeConverters = typeConverters;
		}

		public bool TryGetConverterForType(Type type, [NotNullWhen(true)] out IYamlTypeConverter? typeConverter)
		{
			(bool, IYamlTypeConverter) orAdd = DictionaryExtensions.GetOrAdd(cache, type, (Type t, IYamlTypeConverter[] tc) => LookupTypeConverter(t, tc), typeConverters);
			typeConverter = orAdd.Item2;
			return orAdd.Item1;
		}

		public IYamlTypeConverter GetConverterByType(Type converter)
		{
			IYamlTypeConverter[] array = typeConverters;
			foreach (IYamlTypeConverter yamlTypeConverter in array)
			{
				if (yamlTypeConverter.GetType() == converter)
				{
					return yamlTypeConverter;
				}
			}
			throw new ArgumentException("IYamlTypeConverter of type " + converter.FullName + " not found", "converter");
		}

		private static (bool HasMatch, IYamlTypeConverter? TypeConverter) LookupTypeConverter(Type type, IYamlTypeConverter[] typeConverters)
		{
			foreach (IYamlTypeConverter yamlTypeConverter in typeConverters)
			{
				if (yamlTypeConverter.Accepts(type))
				{
					return (true, yamlTypeConverter);
				}
			}
			return (false, null);
		}
	}
}
namespace YamlDotNet.Serialization.TypeResolvers
{
	internal sealed class DynamicTypeResolver : ITypeResolver
	{
		public Type Resolve(Type staticType, object? actualValue)
		{
			if (actualValue == null)
			{
				return staticType;
			}
			return actualValue.GetType();
		}
	}
	internal class StaticTypeResolver : ITypeResolver
	{
		public virtual Type Resolve(Type staticType, object? actualValue)
		{
			if (actualValue != null)
			{
				if (actualValue.GetType().IsEnum)
				{
					return staticType;
				}
				switch (actualValue.GetType().GetTypeCode())
				{
				case TypeCode.Boolean:
					return typeof(bool);
				case TypeCode.Char:
					return typeof(char);
				case TypeCode.SByte:
					return typeof(sbyte);
				case TypeCode.Byte:
					return typeof(byte);
				case TypeCode.Int16:
					return typeof(short);
				case TypeCode.UInt16:
					return typeof(ushort);
				case TypeCode.Int32:
					return typeof(int);
				case TypeCode.UInt32:
					return typeof(uint);
				case TypeCode.Int64:
					return typeof(long);
				case TypeCode.UInt64:
					return typeof(ulong);
				case TypeCode.Single:
					return typeof(float);
				case TypeCode.Double:
					return typeof(double);
				case TypeCode.Decimal:
					return typeof(decimal);
				case TypeCode.String:
					return typeof(string);
				case TypeCode.DateTime:
					return typeof(DateTime);
				}
			}
			return staticType;
		}
	}
}
namespace YamlDotNet.Serialization.TypeInspectors
{
	internal class CachedTypeInspector : TypeInspectorSkeleton
	{
		private readonly ITypeInspector innerTypeDescriptor;

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

		private readonly ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> enumNameCache = new ConcurrentDictionary<Type, ConcurrentDictionary<string, string>>();

		private readonly ConcurrentDictionary<object, string> enumValueCache = new ConcurrentDictionary<object, string>();

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

		public override string GetEnumName(Type enumType, string name)
		{
			ConcurrentDictionary<string, string> orAdd = enumNameCache.GetOrAdd(enumType, (Type _) => new ConcurrentDictionary<string, string>());
			return DictionaryExtensions.GetOrAdd(orAdd, name, delegate(string n, (Type enumType, ITypeInspector innerTypeDescriptor) context)
			{
				var (enumType2, typeInspector) = context;
				return typeInspector.GetEnumName(enumType2, n);
			}, (enumType, innerTypeDescriptor));
		}

		public override string GetEnumValue(object enumValue)
		{
			return DictionaryExtensions.GetOrAdd(enumValueCache, enumValue, delegate(object _, (object enumValue, ITypeInspector innerTypeDescriptor) context)
			{
				var (enumValue2, typeInspector) = context;
				return typeInspector.GetEnumValue(enumValue2);
			}, (enumValue, innerTypeDescriptor));
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return DictionaryExtensions.GetOrAdd(cache, type, delegate(Type t, (object container, ITypeInspector innerTypeDescriptor) context)
			{
				var (container2, typeInspector) = context;
				return typeInspector.GetProperties(t, container2).ToList();
			}, (container, innerTypeDescriptor));
		}
	}
	internal 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 string GetEnumName(Type enumType, string name)
		{
			foreach (ITypeInspector typeInspector in typeInspectors)
			{
				try
				{
					return typeInspector.GetEnumName(enumType, name);
				}
				catch
				{
				}
			}
			throw new ArgumentOutOfRangeException("enumType,name", "Name not found on enum type");
		}

		public override string GetEnumValue(object enumValue)
		{
			if (enumValue == null)
			{
				throw new ArgumentNullException("enumValue");
			}
			foreach (ITypeInspector typeInspector in typeInspectors)
			{
				try
				{
					return typeInspector.GetEnumValue(enumValue);
				}
				catch
				{
				}
			}
			throw new ArgumentOutOfRangeException("enumValue", $"Value not found for ({enumValue})");
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			Type type2 = type;
			object container2 = container;
			return typeInspectors.SelectMany((ITypeInspector i) => i.GetProperties(type2, container2));
		}
	}
	internal 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 string GetEnumName(Type enumType, string name)
		{
			return innerTypeDescriptor.GetEnumName(enumType, name);
		}

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

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

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

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

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

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return from p in innerTypeDescriptor.GetProperties(type, container)
				where p.CanWrite
				select p;
		}
	}
	internal class ReadableFieldsTypeInspector : ReflectionTypeInspector
	{
		protected class ReflectionFieldDescriptor : IPropertyDescriptor
		{
			private readonly FieldInfo fieldInfo;

			private readonly ITypeResolver typeResolver;

			public string Name => fieldInfo.Name;

			public bool Required => fieldInfo.IsRequired();

			public Type Type => fieldInfo.FieldType;

			public Type? ConverterType { get; }

			public Type? TypeOverride { get; set; }

			public bool AllowNulls => fieldInfo.AcceptsNull();

			public int Order { get; set; }

			public bool CanWrite => !fieldInfo.IsInitOnly;

			public ScalarStyle ScalarStyle { get; set; }

			public ReflectionFieldDescriptor(FieldInfo fieldInfo, ITypeResolver typeResolver)
			{
				this.fieldInfo = fieldInfo;
				this.typeResolver = typeResolver;
				YamlConverterAttribute customAttribute = fieldInfo.GetCustomAttribute<YamlConverterAttribute>();
				if (customAttribute != null)
				{
					ConverterType = customAttribute.ConverterType;
				}
				ScalarStyle = ScalarStyle.Any;
			}

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

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

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

		private readonly ITypeResolver typeResolver;

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

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return type.GetPublicFields().Select((Func<FieldInfo, IPropertyDescriptor>)((FieldInfo p) => new ReflectionFieldDescriptor(p, typeResolver)));
		}
	}
	internal class ReadablePropertiesTypeInspector : ReflectionTypeInspector
	{
		protected class ReflectionPropertyDescriptor : IPropertyDescriptor
		{
			private readonly PropertyInfo propertyInfo;

			private readonly ITypeResolver typeResolver;

			public string Name => propertyInfo.Name;

			public bool Required => propertyInfo.IsRequired();

			public Type Type => propertyInfo.PropertyType;

			public Type? TypeOverride { get; set; }

			public Type? ConverterType { get; set; }

			public bool AllowNulls => propertyInfo.AcceptsNull();

			public int Order { get; set; }

			public bool CanWrite => propertyInfo.CanWrite;

			public 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;
				YamlConverterAttribute customAttribute = propertyInfo.GetCustomAttribute<YamlConverterAttribute>();
				if (customAttribute != null)
				{
					ConverterType = customAttribute.ConverterType;
				}
			}

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

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

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

		private readonly ITypeResolver typeResolver;

		private readonly bool includeNonPublicProperties;

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

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

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

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return type.GetProperties(includeNonPublicProperties).Where(IsValidProperty).Select((Func<PropertyInfo, IPropertyDescriptor>)((PropertyInfo p) => new ReflectionPropertyDescriptor(p, typeResolver)));
		}
	}
	internal abstract class ReflectionTypeInspector : TypeInspectorSkeleton
	{
		public override string GetEnumName(Type enumType, string name)
		{
			return name;
		}

		public override string GetEnumValue(object enumValue)
		{
			if (enumValue == null)
			{
				return string.Empty;
			}
			return enumValue.ToString();
		}
	}
	internal abstract class TypeInspectorSkeleton : ITypeInspector
	{
		public abstract string GetEnumName(Type enumType, string name);

		public abstract string GetEnumValue(object enumValue);

		public abstract IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container);

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

			private readonly ITypeResolver typeResolver;

			public string Name => propertyInfo.Name;

			public bool Required => propertyInfo.IsRequired();

			public Type Type => propertyInfo.PropertyType;

			public Type? TypeOverride { get; set; }

			public Type? ConverterType { get; set; }

			public bool AllowNulls => propertyInfo.AcceptsNull();

			public int Order { get; set; }

			public bool CanWrite => propertyInfo.CanWrite;

			public 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;
				YamlConverterAttribute customAttribute = propertyInfo.GetCustomAttribute<YamlConverterAttribute>();
				if (customAttribute != null)
				{
					ConverterType = customAttribute.ConverterType;
				}
			}

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

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

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

		private readonly ITypeResolver typeResolver;

		private readonly bool includeNonPublicProperties;

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

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

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

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return type.GetProperties(includeNonPublicProperties).Where(IsValidProperty).Select((Func<PropertyInfo, IPropertyDescriptor>)((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
{
	internal sealed class AnchorAssigner : PreProcessingPhaseObjectGraphVisitorSkeleton, IAliasProvider
	{
		private class AnchorAssignment
		{
			public AnchorName Anchor;
		}

		private readonly Dictionary<object, AnchorAssignment> assignments = new Dictionary<object, AnchorAssignment>();

		private uint nextId;

		public AnchorAssigner(IEnumerable<IYamlTypeConverter> typeConverters)
			: base(typeConverters)
		{
		}

		protected override bool Enter(IObjectDescriptor value, ObjectSerializer serializer)
		{
			if (value.Value != null && assignments.TryGetValue(value.Value, out AnchorAssignment value2))
			{
				if (value2.Anchor.IsEmpty)
				{
					value2.Anchor = new AnchorName("o" + nextId.ToString(CultureInfo.InvariantCulture));
					nextId++;
				}
				return false;
			}
			return true;
		}

		protected override bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value, ObjectSerializer serializer)
		{
			return true;
		}

		protected override bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, ObjectSerializer serializer)
		{
			return true;
		}

		protected override void VisitScalar(IObjectDescriptor scalar, ObjectSerializer serializer)
		{
		}

		protected override void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, ObjectSerializer serializer)
		{
			VisitObject(mapping);
		}

		protected override void VisitMappingEnd(IObjectDescriptor mapping, ObjectSerializer serializer)
		{
		}

		protected override void VisitSequenceStart(IObjectDescriptor sequence, Type elementType, ObjectSerializer serializer)
		{
			VisitObject(sequence);
		}

		protected override void VisitSequenceEnd(IObjectDescriptor sequence, ObjectSerializer serializer)
		{
		}

		private void VisitObject(IObjectDescriptor value)
		{
			if (value.Value != null)
			{
				assignments.Add(value.Value, new AnchorAssignment());
			}
		}

		AnchorName IAliasProvider.GetAlias(object target)
		{
			if (target != null && assignments.TryGetValue(target, out AnchorAssignment value))
			{
				return value.Anchor;
			}
			return AnchorName.Empty;
		}
	}
	internal sealed class AnchorAssigningObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		private readonly IEventEmitter eventEmitter;

		private readonly IAliasProvider aliasProvider;

		private readonly HashSet<AnchorName> emittedAliases = new HashSet<AnchorName>();

		public AnchorAssigningObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor, IEventEmitter eventEmitter, IAliasProvider aliasProvider)
			: base(nextVisitor)
		{
			this.eventEmitter = eventEmitter;
			this.aliasProvider = aliasProvider;
		}

		public override bool Enter(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			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(propertyDescriptor, value, context, serializer);
		}

		public override void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, IEmitter context, ObjectSerializer serializer)
		{
			AnchorName alias = aliasProvider.GetAlias(mapping.NonNullValue());
			eventEmitter.Emit(new MappingStartEventInfo(mapping)
			{
				Anchor = alias
			}, context);
		}

		public override void VisitSequenceStart(IObjectDescriptor sequence, Type elementType, IEmitter context, ObjectSerializer serializer)
		{
			AnchorName alias = aliasProvider.GetAlias(sequence.NonNullValue());
			eventEmitter.Emit(new SequenceStartEventInfo(sequence)
			{
				Anchor = alias
			}, context);
		}

		public override void VisitScalar(IObjectDescriptor scalar, IEmitter context, ObjectSerializer serializer)
		{
			ScalarEventInfo scalarEventInfo = new ScalarEventInfo(scalar);
			if (scalar.Value != null)
			{
				scalarEventInfo.Anchor = aliasProvider.GetAlias(scalar.Value);
			}
			eventEmitter.Emit(scalarEventInfo, context);
		}
	}
	internal abstract class ChainedObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
	{
		private readonly IObjectGraphVisitor<IEmitter> nextVisitor;

		protected ChainedObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor)
		{
			this.nextVisitor = nextVisitor;
		}

		public virtual bool Enter(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			return nextVisitor.Enter(propertyDescriptor, value, context, serializer);
		}

		public virtual bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			return nextVisitor.EnterMapping(key, value, context, serializer);
		}

		public virtual bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			return nextVisitor.EnterMapping(key, value, context, serializer);
		}

		public virtual void VisitScalar(IObjectDescriptor scalar, IEmitter context, ObjectSerializer serializer)
		{
			nextVisitor.VisitScalar(scalar, context, serializer);
		}

		public virtual void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, IEmitter context, ObjectSerializer serializer)
		{
			nextVisitor.VisitMappingStart(mapping, keyType, valueType, context, serializer);
		}

		public virtual void VisitMappingEnd(IObjectDescriptor mapping, IEmitter context, ObjectSerializer serializer)
		{
			nextVisitor.VisitMappingEnd(mapping, context, serializer);
		}

		public virtual void VisitSequenceStart(IObjectDescriptor sequence, Type elementType, IEmitter context, ObjectSerializer serializer)
		{
			nextVisitor.VisitSequenceStart(sequence, elementType, context, serializer);
		}

		public virtual void VisitSequenceEnd(IObjectDescriptor sequence, IEmitter context, ObjectSerializer serializer)
		{
			nextVisitor.VisitSequenceEnd(sequence, context, serializer);
		}
	}
	internal sealed class CommentsObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		public CommentsObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor)
			: base(nextVisitor)
		{
		}

		public override bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			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, serializer);
		}
	}
	internal sealed class CustomSerializationObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		private readonly TypeConverterCache typeConverters;

		private readonly ObjectSerializer nestedObjectSerializer;

		public CustomSerializationObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor, IEnumerable<IYamlTypeConverter> typeConverters, ObjectSerializer nestedObjectSerializer)
			: base(nextVisitor)
		{
			this.typeConverters = new TypeConverterCache(typeConverters);
			this.nestedObjectSerializer = nestedObjectSerializer;
		}

		public override bool Enter(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			if (propertyDescriptor?.ConverterType != null)
			{
				IYamlTypeConverter converterByType = typeConverters.GetConverterByType(propertyDescriptor.ConverterType);
				converterByType.WriteYaml(context, value.Value, value.Type, serializer);
				return false;
			}
			if (typeConverters.TryGetConverterForType(value.Type, out IYamlTypeConverter typeConverter))
			{
				typeConverter.WriteYaml(context, value.Value, value.Type, serializer);
				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(propertyDescriptor, value, context, serializer);
		}
	}
	internal sealed class DefaultExclusiveObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		public DefaultExclusiveObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor)
			: base(nextVisitor)
		{
		}

		private static object? GetDefault(Type type)
		{
			if (!type.IsValueType())
			{
				return null;
			}
			return Activator.CreateInstance(type);
		}

		public override bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			if (!object.Equals(value.Value, GetDefault(value.Type)))
			{
				return base.EnterMapping(key, value, context, serializer);
			}
			return false;
		}

		public override bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			DefaultValueAttribute customAttribute = key.GetCustomAttribute<DefaultValueAttribute>();
			object objB = ((customAttribute != null) ? customAttribute.Value : GetDefault(key.Type));
			if (!object.Equals(value.Value, objB))
			{
				return base.EnterMapping(key, value, context, serializer);
			}
			return false;
		}
	}
	internal sealed class DefaultValuesObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		private readonly DefaultValuesHandling handling;

		private readonly IObjectFactory factory;

		public DefaultValuesObjectGraphVisitor(DefaultValuesHandling handling, IObjectGraphVisitor<IEmitter> nextVisitor, IObjectFactory factory)
			: base(nextVisitor)
		{
			this.handling = handling;
			this.factory = factory;
		}

		private object? GetDefault(Type type)
		{
			return factory.CreatePrimitive(type);
		}

		public override bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			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, serializer);
		}
	}
	internal sealed class EmittingObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
	{
		private readonly IEventEmitter eventEmitter;

		public EmittingObjectGraphVisitor(IEventEmitter eventEmitter)
		{
			this.eventEmitter = eventEmitter;
		}

		bool IObjectGraphVisitor<IEmitter>.Enter(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			return true;
		}

		bool IObjectGraphVisitor<IEmitter>.EnterMapping(IObjectDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			return true;
		}

		bool IObjectGraphVisitor<IEmitter>.EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			return true;
		}

		void IObjectGraphVisitor<IEmitter>.VisitScalar(IObjectDescriptor scalar, IEmitter context, ObjectSerializer serializer)
		{
			eventEmitter.Emit(new ScalarEventInfo(scalar), context);
		}

		void IObjectGraphVisitor<IEmitter>.VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, IEmitter context, ObjectSerializer serializer)
		{
			eventEmitter.Emit(new MappingStartEventInfo(mapping), context);
		}

		void IObjectGraphVisitor<IEmitter>.VisitMappingEnd(IObjectDescriptor mapping, IEmitter context, ObjectSerializer serializer)
		{
			eventEmitter.Emit(new MappingEndEventInfo(mapping), context);
		}

		void IObjectGraphVisitor<IEmitter>.VisitSequenceStart(IObjectDescriptor sequence, Type elementType, IEmitter context, ObjectSerializer serializer)
		{
			eventEmitter.Emit(new SequenceStartEventInfo(sequence), context);
		}

		void IObjectGraphVisitor<IEmitter>.VisitSequenceEnd(IObjectDescriptor sequence, IEmitter context, ObjectSerializer serializer)
		{
			eventEmitter.Emit(new SequenceEndEventInfo(sequence), context);
		}
	}
	internal abstract class PreProcessingPhaseObjectGraphVisitorSkeleton : IObjectGraphVisitor<Nothing>
	{
		protected readonly IEnumerable<IYamlTypeConverter> typeConverters;

		private readonly TypeConverterCache typeConverterCache;

		public PreProcessingPhaseObjectGraphVisitorSkeleton(IEnumerable<IYamlTypeConverter> typeConverters)
		{
			typeConverterCache = new TypeConverterCache((IYamlTypeConverter[])(this.typeConverters = typeConverters?.ToArray() ?? Array.Empty<IYamlTypeConverter>()));
		}

		bool IObjectGraphVisitor<Nothing>.Enter(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, Nothing context, ObjectSerializer serializer)
		{
			if (typeConverterCache.TryGetConverterForType(value.Type, out IYamlTypeConverter _))
			{
				return false;
			}
			if (value.Value is IYamlConvertible)
			{
				return false;
			}
			if (value.Value is IYamlSerializable)
			{
				return false;
			}
			return Enter(value, serializer);
		}

		bool IObjectGraphVisitor<Nothing>.EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, Nothing context, ObjectSerializer serializer)
		{
			return EnterMapping(key, value, serializer);
		}

		bool IObjectGraphVisitor<Nothing>.EnterMapping(IObjectDescriptor key, IObjectDescriptor value, Nothing context, ObjectSerializer serializer)
		{
			return EnterMapping(key, value, serializer);
		}

		void IObjectGraphVisitor<Nothing>.VisitMappingEnd(IObjectDescriptor mapping, Nothing context, ObjectSerializer serializer)
		{
			VisitMappingEnd(mapping, serializer);
		}

		void IObjectGraphVisitor<Nothing>.VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, Nothing context, ObjectSerializer serializer)
		{
			VisitMappingStart(mapping, keyType, valueType, serializer);
		}

		void IObjectGraphVisitor<Nothing>.VisitScalar(IObjectDescriptor scalar, Nothing context, ObjectSerializer serializer)
		{
			VisitScalar(scalar, serializer);
		}

		void IObjectGraphVisitor<Nothing>.VisitSequenceEnd(IObjectDescriptor sequence, Nothing context, ObjectSerializer serializer)
		{
			VisitSequenceEnd(sequence, serializer);
		}

		void IObjectGraphVisitor<Nothing>.VisitSequenceStart(IObjectDescriptor sequence, Type elementType, Nothing context, ObjectSerializer serializer)
		{
			VisitSequenceStart(sequence, elementType, serializer);
		}

		protected abstract bool Enter(IObjectDescriptor value, ObjectSerializer serializer);

		protected abstract bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, ObjectSerializer serializer);

		protected abstract bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value, ObjectSerializer serializer);

		protected abstract void VisitMappingEnd(IObjectDescriptor mapping, ObjectSerializer serializer);

		protected abstract void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, ObjectSerializer serializer);

		protected abstract void VisitScalar(IObjectDescriptor scalar, ObjectSerializer serializer);

		protected abstract void VisitSequenceEnd(IObjectDescriptor sequence, ObjectSerializer serializer);

		protected abstract void VisitSequenceStart(IObjectDescriptor sequence, Type elementType, ObjectSerializer serializer);
	}
}
namespace YamlDotNet.Serialization.ObjectGraphTraversalStrategies
{
	internal class FullObjectGraphTraversalStrategy : IObjectGraphTraversalStrategy
	{
		protected readonly 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<TContext>(IObjectDescriptor graph, IObjectGraphVisitor<TContext> visitor, TContext context, ObjectSerializer serializer)
		{
			Traverse(null, "<root>", graph, visitor, context, new Stack<ObjectPathSegment>(maxRecursion), serializer);
		}

		protected virtual void Traverse<TContext>(IPropertyDescriptor? propertyDescriptor, object name, IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path, ObjectSerializer serializer)
		{
			if (path.Count >= maxRecursion)
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("Too much recursion when traversing the object graph.");
				stringBuilder.AppendLine("The path to reach this recursion was:");
				Stack<KeyValuePair<string, string>> stack = new Stack<KeyValuePair<string, string>>(path.Count);
				int num = 0;
				foreach (ObjectPathSegment item in path)
				{
					string text = item.Name?.ToString() ?? string.Empty;
					num = Math.Max(num, text.Length);
					stack.Push(new KeyValuePair<string, string>(text, item.Value.Type.FullName));
				}
				foreach (KeyValuePair<string, string> item2 in stack)
				{
					stringBuilder.Append(" -> ").Append(item2.Key.PadRight(num)).Append("  [")
						.Append(item2.Value)
						.AppendLine("]");
				}
				throw new MaximumRecursionLevelReachedException(stringBuilder.ToString());
			}
			if (!visitor.Enter(propertyDescriptor, value, context, serializer))
			{
				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, serializer);
					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, serializer);
				}
				if (value.Value == null || value.Type == typeof(TimeSpan))
				{
					visitor.VisitScalar(value, context, serializer);
					return;
				}
				Type underlyingType = Nullable.GetUnderlyingType(value.Type);
				Type type = underlyingType ?? FsharpHelper.GetOptionUnderlyingType(value.Type);
				object obj = ((type != null) ? FsharpHelper.GetValue(value) : null);
				if (underlyingType != null)
				{
					Traverse(propertyDescriptor, "Value", new ObjectDescriptor(value.Value, underlyingType, value.Type, value.ScalarStyle), visitor, context, path, serializer);
				}
				else if (type != null && obj != null)
				{
					Traverse(propertyDescriptor, "Value", new ObjectDescriptor(FsharpHelper.GetValue(value), type, value.Type, value.ScalarStyle), visitor, context, path, serializer);
				}
				else
				{
					TraverseObject(propertyDescriptor, value, visitor, context, path, serializer);
				}
			}
			finally
			{
				path.Pop();
			}
		}

		protected virtual void TraverseObject<TContext>(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path, ObjectSerializer serializer)
		{
			IDictionary dictionary;
			Type[] genericArguments;
			if (typeof(IDictionary).IsAssignableFrom(value.Type))
			{
				TraverseDictionary(propertyDescriptor, value, visitor, typeof(object), typeof(object), context, path, serializer);
			}
			else if (objectFactory.GetDictionary(value, out dictionary, out genericArguments))
			{
				TraverseDictionary(propertyDescriptor, new ObjectDescriptor(dictionary, value.Type, value.StaticType, value.ScalarStyle), visitor, genericArguments[0], genericArguments[1], context, path, serializer);
			}
			else if (typeof(IEnumerable).IsAssignableFrom(value.Type))
			{
				TraverseList(propertyDescriptor, value, visitor, context, path, serializer);
			}
			else
			{
				TraverseProperties(value, visitor, context, path, serializer);
			}
		}

		protected virtual void TraverseDictionary<TContext>(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor dictionary, IObjectGraphVisitor<TContext> visitor, Type keyType, Type valueType, TContext context, Stack<ObjectPathSegment> path, ObjectSerializer serializer)
		{
			visitor.VisitMappingStart(dictionary, keyType, valueType, context, serializer);
			bool flag = dictionary.Type.FullName.Equals("System.Dynamic.ExpandoObject");
			foreach (DictionaryEntry? item in (IDictionary)dictionary.NonNullValue())
			{
				DictionaryEntry value = item.Value;
				object obj = (flag ? namingConvention.Apply(value.Key.ToString()) : value.Key);
				ObjectDescriptor objectDescriptor = GetObjectDescriptor(obj, keyType);
				ObjectDescriptor objectDescriptor2 = GetObjectDescriptor(value.Value, valueType);
				if (visitor.EnterMapping(objectDescriptor, objectDescriptor2, context, serializer))
				{
					Traverse(propertyDescriptor, obj, objectDescriptor, visitor, context, path, serializer);
					Traverse(propertyDescriptor, obj, objectDescriptor2, visitor, context, path, serializer);
				}
			}
			visitor.VisitMappingEnd(dictionary, context, serializer);
		}

		private void TraverseList<TContext>(IPropertyDescriptor propertyDescriptor, IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path, ObjectSerializer serializer)
		{
			Type valueType = objectFactory.GetValueType(value.Type);
			visitor.VisitSequenceStart(value, valueType, context, serializer);
			int num = 0;
			foreach (object item in (IEnumerable)value.NonNullValue())
			{
				Traverse(propertyDescriptor, num, GetObjectDescriptor(item, valueType), visitor, context, path, serializer);
				num++;
			}
			visitor.VisitSequenceEnd(value, context, serializer);
		}

		protected virtual void TraverseProperties<TContext>(IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path, ObjectSerializer serializer)
		{
			if (context.GetType() != typeof(Nothing))
			{
				objectFactory.ExecuteOnSerializing(value.Value);
			}
			visitor.VisitMappingStart(value, typeof(string), typeof(object), context, serializer);
			object obj = value.NonNullValue();
			foreach (IPropertyDescriptor property in typeDescriptor.GetProperties(value.Type, obj))
			{
				IObjectDescriptor value2 = property.Read(obj);
				if (visitor.EnterMapping(property, value2, context, serializer))
				{
					Traverse(null, property.Name, new ObjectDescriptor(property.Name, typeof(string), typeof(string), ScalarStyle.Plain), visitor, context, path, serializer);
					Traverse(property, property.Name, value2, visitor, context, path, serializer);
				}
			}
			visitor.VisitMappingEnd(value, context, serializer);
			if (context.GetType() != typeof(Nothing))
			{
				objectFactory.ExecuteOnSerialized(value.Value);
			}
		}

		private ObjectDescriptor GetObjectDescriptor(object? value, Type staticType)
		{
			return new ObjectDescriptor(value, typeResolver.Resolve(staticType, value), staticType);
		}
	}
	internal class RoundtripObjectGraphTraversalStrategy : FullObjectGraphTraversalStrategy
	{
		private readonly TypeConverterCache 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 = new TypeConverterCache(converters);
			this.settings = settings;
		}

		protected override void TraverseProperties<TContext>(IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path, ObjectSerializer serializer)
		{
			if (!value.Type.HasDefaultConstructor(settings.AllowPrivateConstructors) && !converters.TryGetConverterForType(value.Type, out IYamlTypeConverter _))
			{
				throw new InvalidOperationException($"Type '{value.Type}' cannot be deserialized because it does not have a default constructor or a type converter.");
			}
			base.TraverseProperties(value, visitor, context, path, serializer);
		}
	}
}
namespace YamlDotNet.Serialization.ObjectFactories
{
	internal class DefaultObjectFactory : ObjectFactoryBase
	{
		private readonly Dictionary<Type, ConcurrentDictionary<Type, MethodInfo[]>> stateMethods = new Dictionary<Type, ConcurrentDictionary<Type, MethodInfo[]>>
		{
			{
				typeof(YamlDotNet.Serialization.Callbacks.OnDeserializedAttribute),
				new ConcurrentDictionary<Type, MethodInfo[]>()
			},
			{
				typeof(YamlDotNet.Serialization.Callbacks.OnDeserializingAttribute),
				new ConcurrentDictionary<Type, MethodInfo[]>()
			},
			{
				typeof(YamlDotNet.Serialization.Callbacks.OnSerializedAttribute),
				new ConcurrentDictionary<Type, MethodInfo[]>()
			},
			{
				typeof(YamlDotNet.Serialization.Callbacks.OnSerializingAttribute),
				new ConcurrentDictionary<Type, MethodInfo[]>()
			}
		};

		private readonly Dictionary<Type, Type> defaultGenericInterfaceImplementations = new Dictionary<Type, Type>
		{
			{
				typeof(IEnumerable<>),
				typeof(List<>)
			},
			{
				typeof(ICollection<>),
				typeof(List<>)
			},
			{
				typeof(IList<>),
				typeof(List<>)
			},
			{
				typeof(IDictionary<, >),
				typeof(Dictionary<, >)
			}
		};

		private readonly Dictionary<Type, Type> defaultNonGenericInterfaceImplementations = new Dictionary<Type, Type>
		{
			{
				typeof(IEnumerable),
				typeof(List<object>)
			},
			{
				typeof(ICollection),
				typeof(List<object>)
			},
			{
				typeof(IList),
				typeof(List<object>)
			},
			{
				typeof(IDictionary),
				typeof(Dictionary<object, object>)
			}
		};

		private readonly Settings settings;

		public DefaultObjectFactory()
			: this(new Dictionary<Type, Type>(), new Settings())
		{
		}

		public DefaultObjectFactory(IDictionary<Type, Type> mappings)
			: this(mappings, new Settings())
		{
		}

		public DefaultObjectFactory(IDictionary<Type, Type> mappings, Settings settings)
		{
			foreach (KeyValuePair<Type, Type> mapping in mappings)
			{
				if (!mapping.Key.IsAssignableFrom(mapping.Value))
				{
					throw new InvalidOperationException($"Type '{mapping.Value}' does not implement type '{mapping.Key}'.");
				}
				defaultNonGenericInterfaceImplementations.Add(mapping.Key, mapping.Value);
			}
			this.settings = settings;
		}

		public override object Create(Type type)
		{
			if (type.IsInterface())
			{
				Type value2;
				if (type.IsGenericType())
				{
					if (defaultGenericInterfaceImplementations.TryGetValue(type.GetGenericTypeDefinition(), out Type value))
					{
						type = value.MakeGenericType(type.GetGenericArguments());
					}
				}
				else if (defaultNonGenericInterfaceImplementations.TryGetValue(type, out value2))
				{
					type = value2;
				}
			}
			try
			{
				return Activator.CreateInstance(type, settings.AllowPrivateConstructors);
			}
			catch (Exception innerException)
			{
				string message = "Failed to create an instance of type '" + type.FullName + "'.";
				throw new InvalidOperationException(message, innerException);
			}
		}

		public override void ExecuteOnDeserialized(object value)
		{
			ExecuteState(typeof(YamlDotNet.Serialization.Callbacks.OnDeserializedAttribute), value);
		}

		public override void ExecuteOnDeserializing(object value)
		{
			ExecuteState(typeof(YamlDotNet.Serialization.Callbacks.OnDeserializingAttribute), value);
		}

		public override void ExecuteOnSerialized(object value)
		{
			ExecuteState(typeof(YamlDotNet.Serialization.Callbacks.OnSerializedAttribute), value);
		}

		public override void ExecuteOnSerializing(object value)
		{
			ExecuteState(typeof(YamlDotNet.Serialization.Callbacks.OnSerializingAttribute), value);
		}

		private void ExecuteState(Type attributeType, object value)
		{
			if (value != null)
			{
				Type type = value.GetType();
				MethodInfo[] array = GetStateMethods(attributeType, type);
				MethodInfo[] array2 = array;
				foreach (MethodInfo methodInfo in array2)
				{
					methodInfo.Invoke(value, null);
				}
			}
		}

		private MethodInfo[] GetStateMethods(Type attributeType, Type valueType)
		{
			Type attributeType2 = attributeType;
			ConcurrentDictionary<Type, MethodInfo[]> concurrentDictionary = stateMethods[attributeType2];
			return concurrentDictionary.GetOrAdd(valueType, delegate(Type type)
			{
				MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				return methods.Where((MethodInfo x) => x.GetCustomAttributes(attributeType2, inherit: true).Length != 0).ToArray();
			});
		}
	}
	internal sealed class 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);
		}
	}
	internal abstract class ObjectFactoryBase : IObjectFactory
	{
		public abstract object Create(Type type);

		public virtual object? CreatePrimitive(Type type)
		{
			if (!type.IsValueType())
			{
				return null;
			}
			return Activator.CreateInstance(type);
		}

		public virtual void ExecuteOnDeserialized(object value)
		{
		}

		public virtual void ExecuteOnDeserializing(object value)
		{
		}

		public virtual void ExecuteOnSerialized(object value)
		{
		}

		public virtual void ExecuteOnSerializing(object value)
		{
		}

		public virtual bool GetDictionary(IObjectDescriptor descriptor, out IDictionary? dictionary, out Type[]? genericArguments)
		{
			Type implementationOfOpenGenericInterface = descriptor.Type.GetImplementationOfOpenGenericInterface(typeof(IDictionary<, >));
			if (implementationOfOpenGenericInterface != null)
			{
				genericArguments = implementationOfOpenGenericInterface.GetGenericArguments();
				object obj = Activator.CreateInstance(typeof(GenericDictionaryToNonGenericAdapter<, >).MakeGenericType(genericArguments), descriptor.Value);
				dictionary = obj as IDictionary;
				return true;
			}
			genericArguments = null;
			dictionary = null;
			return false;
		}

		public virtual Type GetValueType(Type type)
		{
			Type implementationOfOpenGenericInterface = type.GetImplementationOfOpenGenericInterface(typeof(IEnumerable<>));
			return (implementationOfOpenGenericInterface != null) ? implementationOfOpenGenericInterface.GetGenericArguments()[0] : typeof(object);
		}
	}
	internal abstract class StaticObjectFactory : IObjectFactory
	{
		public abstract object Create(Type type);

		public abstract Array CreateArray(Type type, int count);

		public abstract bool IsDictionary(Type type);

		public abstract bool IsArray(Type type);

		public abstract bool IsList(Type type);

		public abstract Type GetKeyType(Type type);

		public abstract Type GetValueType(Type type);

		public virtual object? CreatePrimitive(Type type)
		{
			return Type.GetTypeCode(type) switch
			{
				TypeCode.Boolean => false, 
				TypeCode.Byte => (byte)0, 
				TypeCode.Int16 => (short)0, 
				TypeCode.Int32 => 0, 
				TypeCode.Int64 => 0L, 
				TypeCode.SByte => (sbyte)0, 
				TypeCode.UInt16 => (ushort)0, 
				TypeCode.UInt32 => 0u, 
				TypeCode.UInt64 => 0uL, 
				TypeCode.Single => 0f, 
				TypeCode.Double => 0.0, 
				TypeCode.Decimal => 0m, 
				TypeCode.Char => '\0', 
				TypeCode.DateTime => default(DateTime), 
				_ => null, 
			};
		}

		public bool GetDictionary(IObjectDescriptor descriptor, out IDictionary? dictionary, out Type[]? genericArguments)
		{
			dictionary = null;
			genericArguments = null;
			return false;
		}

		public abstract void ExecuteOnDeserializing(object value);

		public abstract void ExecuteOnDeserialized(object value);

		public abstract void ExecuteOnSerializing(object value);

		public abstract void ExecuteOnSerialized(object value);
	}
}
namespace YamlDotNet.Serialization.NodeTypeResolvers
{
	internal sealed class DefaultContainersNodeTypeResolver : INodeTypeResolver
	{
		bool INodeTypeResolver.Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			if (currentType == typeof(object))
			{
				if (nodeEvent is SequenceStart)
				{
					currentType = typeof(List<object>);
					return true;
				}
				if (nodeEvent is MappingStart)
				{
					currentType = typeof(Dictionary<object, object>);
					return true;
				}
			}
			return false;
		}
	}
	internal class MappingNodeTypeResolver : INodeTypeResolver
	{
		private readonly IDictionary<Type, Type> mappings;

		public MappingNodeTypeResolver(IDictionary<Type, Type> mappings)
		{
			if (mappings == null)
			{
				throw new ArgumentNullException("mappings");
			}
			foreach (KeyValuePair<Type, Type> mapping in mappings)
			{
				if (!mapping.Key.IsAssignableFrom(mapping.Value))
				{
					throw new InvalidOperationException($"Type '{mapping.Value}' does not implement type '{mapping.Key}'.");
				}
			}
			this.mappings = mappings;
		}

		public bool Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			if (mappings.TryGetValue(currentType, out Type value))
			{
				currentType = value;
				return true;
			}
			return false;
		}
	}
	internal class PreventUnknownTagsNodeTypeResolver : INodeTypeResolver
	{
		bool INodeTypeResolver.Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			if (nodeEvent != null && !nodeEvent.Tag.IsEmpty)
			{
				Mark start = nodeEvent.Start;
				Mark end = nodeEvent.End;
				throw new YamlException(in start, in end, $"Encountered an unresolved tag '{nodeEvent.Tag}'");
			}
			return false;
		}
	}
	internal sealed class TagNodeTypeResolver : INodeTypeResolver
	{
		private readonly IDictionary<TagName, Type> tagMappings;

		public TagNodeTypeResolver(IDictionary<TagName, Type> tagMappings)
		{
			this.tagMappings = tagMappings ?? throw new ArgumentNullException("tagMappings");
		}

		bool INodeTypeResolver.Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			if (nodeEvent != null && !nodeEvent.Tag.IsEmpty && tagMappings.TryGetValue(nodeEvent.Tag, out Type value))
			{
				currentType = value;
				return true;
			}
			return false;
		}
	}
	[Obsolete("The mechanism that this class uses to specify type names is non-standard. Register the tags explicitly instead of using this convention.")]
	internal sealed class TypeNameInTagNodeTypeResolver : INodeTypeResolver
	{
		bool INodeTypeResolver.Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			if (nodeEvent != null && !nodeEvent.Tag.IsEmpty)
			{
				Type type = Type.GetType(nodeEvent.Tag.Value.Substring(1), throwOnError: false);
				if (type != null)
				{
					currentType = type;
					return true;
				}
			}
			return false;
		}
	}
	internal sealed class YamlConvertibleTypeResolver : INodeTypeResolver
	{
		public bool Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			return typeof(IYamlConvertible).IsAssignableFrom(currentType);
		}
	}
	internal sealed class YamlSerializableTypeResolver : INodeTypeResolver
	{
		public bool Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			return typeof(IYamlSerializable).IsAssignableFrom(currentType);
		}
	}
}
namespace YamlDotNet.Serialization.NodeDeserializers
{
	internal sealed class ArrayNodeDeserializer : INodeDeserializer
	{
		private sealed class ArrayList : IList, ICollection, IEnumerable
		{
			private object?[] data;

			public bool IsFixedSize => false;

			public bool IsReadOnly => false;

			public object? this[int index]
			{
				get
				{
					return data[index];
				}
				set
				{
					data[index] = value;
				}
			}

			public int Count { get; private set; }

			public bool IsSynchronized => false;

			public object SyncRoot => data;

			public ArrayList()
			{
				Clear();
			}

			public int Add(object? value)
			{
				if (Count == data.Length)
				{
					Array.Resize(ref data, data.Length * 2);
				}
				data[Count] = value;
				return Count++;
			}

			public void Clear()
			{
				data = new object[10];
				Count = 0;
			}

			bool IList.Contains(object? value)
			{
				throw new NotSupportedException();
			}

			int IList.IndexOf(object? value)
			{
				throw new NotSupportedException();
			}

			void IList.Insert(int index, object? value)
			{
				throw new NotSupportedException();
			}

			void IList.Remove(object? value)
			{
				throw new NotSupportedException();
			}

			void IList.RemoveAt(int index)
			{
				throw new NotSupportedException();
			}

			public void CopyTo(Array array, int index)
			{
				Array.Copy(data, 0, array, index, Count);
			}

			public IEnumerator GetEnumerator()
			{
				int i = 0;
				while (i < Count)
				{
					yield return data[i];
					int num = i + 1;
					i = num;
				}
			}
		}

		private readonly INamingConvention enumNamingConvention;

		private readonly ITypeInspector typeInspector;

		public ArrayNodeDeserializer(INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			this.enumNamingConvention = enumNamingConvention;
			this.typeInspector = typeInspector;
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!expectedType.IsArray)
			{
				value = false;
				return false;
			}
			Type itemType = expectedType.GetElementType();
			ArrayList arrayList = new ArrayList();
			Array array = null;
			CollectionNodeDeserializer.DeserializeHelper(itemType, parser, nestedObjectDeserializer, arrayList, canUpdate: true, enumNamingConvention, typeInspector, PromiseResolvedHandler);
			array = Array.CreateInstance(itemType, arrayList.Count);
			arrayList.CopyTo(array, 0);
			value = array;
			return true;
			void PromiseResolvedHandler(int index, object? value)
			{
				if (array == null)
				{
					throw new InvalidOperationException("Destination array is still null");
				}
				array.SetValue(YamlDotNet.Serialization.Utilities.TypeConverter.ChangeType(value, itemType, enumNamingConvention, typeInspector), index);
			}
		}
	}
	internal abstract class CollectionDeserializer
	{
		protected static void DeserializeHelper(Type tItem, IParser parser, Func<IParser, Type, object?> nestedObjectDeserializer, IList result, bool canUpdate, IObjectFactory objectFactory)
		{
			IList result2 = result;
			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 = result2.Add(objectFactory.CreatePrimitive(tItem));
					valuePromise.ValueAvailable += delegate(object? v)
					{
						result2[index] = v;
					};
				}
				else
				{
					result2.Add(obj);
				}
			}
		}
	}
	internal sealed class CollectionNodeDeserializer : INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		private readonly INamingConvention enumNamingConvention;

		private readonly ITypeInspector typeInspector;

		public CollectionNodeDeserializer(IObjectFactory objectFactory, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
			this.enumNamingConvention = enumNamingConvention;
			this.typeInspector = typeInspector;
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			bool canUpdate = true;
			Type implementationOfOpenGenericInterface = expectedType.GetImplementationOfOpenGenericInterface(typeof(ICollection<>));
			Type type;
			IList list;
			if (implementationOfOpenGenericInterface != null)
			{
				Type[] genericArguments = implementationOfOpenGenericInterface.GetGenericArguments();
				type = genericArguments[0];
				value = objectFactory.Create(expectedType);
				list = value as IList;
				if (list == null)
				{
					Type implementationOfOpenGenericInterface2 = expectedType.GetImplementationOfOpenGenericInterface(typeof(IList<>));
					canUpdate = implementationOfOpenGenericInterface2 != null;
					list = (IList)Activator.CreateInstance(typeof(GenericCollectionToNonGenericAdapter<>).MakeGenericType(type), value);
				}
			}
			else
			{
				if (!typeof(IList).IsAssignableFrom(expectedType))
				{
					value = null;
					return false;
				}
				type = typeof(object);
				value = objectFactory.Create(expectedType);
				list = (IList)value;
			}
			DeserializeHelper(type, parser, nestedObjectDeserializer, list, canUpdate, enumNamingConvention, typeInspector);
			return true;
		}

		internal static void DeserializeHelper(Type tItem, IParser parser, Func<IParser, Type, object?> nestedObjectDeserializer, IList result, bool canUpdate, INamingConvention enumNamingConvention, ITypeInspector typeInspector, Action<int, object?>? promiseResolvedHandler = null)
		{
			Action<int, object?> promiseResolvedHandler2 = promiseResolvedHandler;
			IList result2 = result;
			Type tItem2 = tItem;
			INamingConvention enumNamingConvention2 = enumNamingConvention;
			ITypeInspector typeInspector2 = typeInspector;
			parser.Consume<SequenceStart>();
			SequenceEnd @event;
			while (!parser.TryConsume<SequenceEnd>(out @event))
			{
				ParsingEvent current = parser.Current;
				object obj = nestedObjectDeserializer(parser, tItem2);
				if (obj is IValuePromise valuePromise)
				{
					if (!canUpdate)
					{
						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 = result2.Add(tItem2.IsValueType() ? Activator.CreateInstance(tItem2) : null);
					if (promiseResolvedHandler2 != null)
					{
						valuePromise.ValueAvailable += delegate(object? v)
						{
							promiseResolvedHandler2(index, v);
						};
					}
					else
					{
						valuePromise.ValueAvailable += delegate(object? v)
						{
							result2[index] = YamlDotNet.Serialization.Utilities.TypeConverter.ChangeType(v, tItem2, enumNamingConvention2, typeInspector2);
						};
					}
				}
				else
				{
					result2.Add(YamlDotNet.Serialization.Utilities.TypeConverter.ChangeType(obj, tItem2, enumNamingConvention2, typeInspector2));
				}
			}
		}
	}
	internal abstract class DictionaryDeserializer
	{
		private readonly bool duplicateKeyChecking;

		public DictionaryDeserializer(bool duplicateKeyChecking)
		{
			this.duplicateKeyChecking = duplicateKeyChecking;
		}

		private void TryAssign(IDictionary result, object key, object value, 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, Func<IParser, Type, object?> nestedObjectDeserializer, IDictionary result, ObjectDeserializer rootDeserializer)
		{
			IDictionary result2 = result;
			MappingStart property = parser.Consume<MappingStart>();
			MappingEnd @event;
			while (!parser.TryConsume<MappingEnd>(out @event))
			{
				object key = nestedObjectDeserializer(parser, tKey);
				object value = nestedObjectDeserializer(parser, tValue);
				IValuePromise valuePromise = value as IValuePromise;
				if (key is IValuePromise valuePromise2)
				{
					if (valuePromise == null)
					{
						valuePromise2.ValueAvailable += delegate(object? v)
						{
							result2[v] = value;
						};
						continue;
					}
					bool hasFirstPart = false;
					valuePromise2.ValueAvailable += delegate(object? v)
					{
						if (hasFirstPart)
						{
							TryAssign(result2, v, value, property);
						}
						else
						{
							key = v;
							hasFirstPart = true;
						}
					};
					valuePromise.ValueAvailable += delegate(object? v)
					{
						if (hasFirstPart)
						{
							TryAssign(result2, key, v, property);
						}
						else
						{
							value = v;
							hasFirstPart = true;
						}
					};
					continue;
				}
				if (key == null)
				{
					throw new ArgumentException("Empty key names are not supported yet.", "tKey");
				}
				if (valuePromise == null)
				{
					TryAssign(result2, key, value, property);
					continue;
				}
				valuePromise.ValueAvailable += delegate(object? v)
				{
					result2[key] = v;
				};
			}
		}
	}
	internal class DictionaryNodeDeserializer : DictionaryDeserializer, INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		public DictionaryNodeDeserializer(IObjectFactory objectFactory, bool duplicateKeyChecking)
			: base(duplicateKeyChecking)
		{
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			Type implementationOfOpenGenericInterface = expectedType.GetImplementationOfOpenGenericInterface(typeof(IDictionary<, >));
			Type type;
			Type type2;
			IDictionary dictionary;
			if (implementationOfOpenGenericInterface != null)
			{
				Type[] genericArguments = implementationOfOpenGenericInterface.GetGenericArguments();
				type = genericArguments[0];
				type2 = genericArguments[1];
				value = objectFactory.Create(expectedType);
				dictionary = value as IDictionary;
				if (dictionary == null)
				{
					dictionary = (IDictionary)Activator.CreateInstance(typeof(GenericDictionaryToNonGenericAdapter<, >).MakeGenericType(type, type2), value);
				}
			}
			else
			{
				if (!typeof(IDictionary).IsAssignableFrom(expectedType))
				{
					value = null;
					return false;
				}
				type = typeof(object);
				type2 = typeof(object);
				value = objectFactory.Create(expectedType);
				dictionary = (IDictionary)value;
			}
			Deserialize(type, type2, parser, nestedObjectDeserializer, dictionary, rootDeserializer);
			return true;
		}
	}
	internal sealed class EnumerableNodeDeserializer : INodeDeserializer
	{
		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			Type type;
			if (expectedType == typeof(IEnumerable))
			{
				type = typeof(object);
			}
			else
			{
				Type implementationOfOpenGenericInterface = expectedType.GetImplementationOfOpenGenericInterface(typeof(IEnumerable<>));
				if (implementationOfOpenGenericInterface != expectedType)
				{
					value = null;
					return false;
				}
				type = implementationOfOpenGenericInterface.GetGenericArguments()[0];
			}
			Type arg = typeof(List<>).MakeGenericType(type);
			value = nestedObjectDeserializer(parser, arg);
			return true;
		}
	}
	internal sealed class FsharpListNodeDeserializer : INodeDeserializer
	{
		private readonly ITypeInspector typeInspector;

		private readonly INamingConvention enumNamingConvention;

		public FsharpListNodeDeserializer(ITypeInspector typeInspector, INamingConvention enumNamingConvention)
		{
			this.typeInspector = typeInspector;
			this.enumNamingConvention = enumNamingConvention;
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!FsharpHelper.IsFsharpListType(expectedType))
			{
				value = false;
				return false;
			}
			Type type = expectedType.GetGenericArguments()[0];
			Type t = expectedType.GetGenericTypeDefinition().MakeGenericType(type);
			ArrayList arrayList = new ArrayList();
			CollectionNodeDeserializer.DeserializeHelper(type, parser, nestedObjectDeserializer, arrayList, canUpdate: true, enumNamingConvention, typeInspector);
			Array array = Array.CreateInstance(type, arrayList.Count);
			arrayList.CopyTo(array, 0);
			object obj = FsharpHelper.CreateFsharpListFromArray(t, type, array);
			value = obj;
			return true;
		}
	}
	internal sealed class NullNodeDeserializer : INodeDeserializer
	{
		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			value = null;
			if (parser.Accept<NodeEvent>(out var @event) && NodeIsNull(@event))
			{
				parser.SkipThisAndNestedEvents();
				return true;
			}
			return false;
		}

		private static 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;
		}
	}
	internal sealed class ObjectNodeDeserializer : INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		private readonly ITypeInspector typeInspector;

		private readonly bool ignoreUnmatched;

		private readonly bool duplicateKeyChecking;

		private readonly ITypeConverter typeConverter;

		private readonly INamingConvention enumNamingConvention;

		private readonly bool enforceNullability;

		private readonly bool caseInsensitivePropertyMatching;

		private readonly bool enforceRequiredProperties;

		private readonly TypeConverterCache typeConverters;

		public ObjectNodeDeserializer(IObjectFactory objectFactory, ITypeInspector typeInspector, bool ignoreUnmatched, bool duplicateKeyChecking, ITypeConverter typeConverter, INamingConvention enumNamingConvention, bool enforceNullability, bool caseInsensitivePropertyMatching, bool enforceRequiredProperties, IEnumerable<IYamlTypeConverter> typeConverters)
		{
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
			this.typeInspector = typeInspector ?? throw new ArgumentNullException("typeInspector");
			this.ignoreUnmatched = ignoreUnmatched;
			this.duplicateKeyChecking = duplicateKeyChecking;
			this.typeConverter = typeConverter ?? throw new ArgumentNullException("typeConverter");
			this.enumNamingConvention = enumNamingConvention ?? throw new ArgumentNullException("enumNamingConvention");
			this.enforceNullability = enforceNullability;
			this.caseInsensitivePropertyMatching = caseInsensitivePropertyMatching;
			this.enforceRequiredProperties = enforceRequiredProperties;
			this.typeConverters = new TypeConverterCache(typeConverters);
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!parser.TryConsume<MappingStart>(out var _))
			{
				value = null;
				return false;
			}
			Type type = Nullable.GetUnderlyingType(expectedType) ?? FsharpHelper.GetOptionUnderlyingType(expectedType) ?? expectedType;
			value = objectFactory.Create(type);
			objectFactory.ExecuteOnDeserializing(value);
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			HashSet<string> hashSet2 = new HashSet<string>(StringComparer.Ordinal);
			Mark start = Mark.Empty;
			MappingEnd event2;
			while (!parser.TryConsume<MappingEnd>(out event2))
			{
				YamlDotNet.Core.Events.Scalar propertyName = parser.Consume<YamlDotNet.Core.Events.Scalar>();
				if (duplicateKeyChecking && !hashSet.Add(propertyName.Value))
				{
					Mark start2 = propertyName.Start;
					Mark end = propertyName.End;
					throw new YamlException(in start2, in end, "Encountered duplicate key " + propertyName.Value);
				}
				try
				{
					IPropertyDescriptor property = typeInspector.GetProperty(type, null, propertyName.Value, ignoreUnmatched, caseInsensitivePropertyMatching);
					if (property == null)
					{
						parser.SkipThisAndNestedEvents();
						continue;
					}
					hashSet2.Add(property.Name);
					object obj;
					if (property.ConverterType != null)
					{
						IYamlTypeConverter converterByType = typeConverters.GetConverterByType(property.ConverterType);
						obj = converterByType.ReadYaml(parser, property.Type, rootDeserializer);
					}
					else
					{
						obj = nestedObjectDeserializer(parser, property.Type);
					}
					if (obj is IValuePromise valuePromise)
					{
						object valueRef = value;
						valuePromise.ValueAvailable += delegate(object? v)
						{
							object value3 = typeConverter.ChangeType(v, property.Type, enumNamingConvention, typeInspector);
							NullCheck(value3, property, propertyName);
							property.Write(valueRef, value3);
						};
					}
					else
					{
						object value2 = typeConverter.ChangeType(obj, property.Type, enumNamingConvention, typeInspector);
						NullCheck(value2, property, propertyName);
						property.Write(value, value2);
					}
					goto IL_0267;
				}
				catch (SerializationException ex)
				{
					Mark start2 = propertyName.Start;
					Mark end = propertyName.End;
					throw new YamlException(in start2, in end, ex.Message);
				}
				catch (YamlException)
				{
					throw;
				}
				catch (Exception innerException)
				{
					Mark start2 = propertyName.Start;
					Mark end = propertyName.End;
					throw new YamlException(in start2, in end, "Exception during deserialization", innerException);
				}
				IL_0267:
				start = propertyName.End;
			}
			if (enforceRequiredProperties)
			{
				IEnumerable<IPropertyDescriptor> properties = typeInspector.GetProperties(type, value);
				List<string> list = new List<string>();
				foreach (IPropertyDescriptor item in properties)
				{
					if (item.Required && !hashSet2.Contains(item.Name))
					{
						list.Add(item.Name);
					}
				}
				if (list.Count > 0)
				{
					string text = string.Join(",", list);
					throw new YamlException(in start, in start, "Missing properties, '" + text + "' in source yaml.");
				}
			}
			objectFactory.ExecuteOnDeserialized(value);
			return true;
		}

		public void NullCheck(object value, IPropertyDescriptor property, YamlDotNet.Core.Events.Scalar propertyName)
		{
			if (enforceNullability && value == null && !property.AllowNulls)
			{
				Mark start = propertyName.Start;
				Mark end = propertyName.End;
				throw new YamlException(in start, in end, "Strict nullability enforcement error.", new NullReferenceException("Yaml value is null when target property requires non null values."));
			}
		}
	}
	internal sealed class 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;

		private readonly ITypeInspector typeInspector;

		private readonly YamlFormatter formatter;

		private readonly INamingConvention enumNamingConvention;

		public ScalarNodeDeserializer(bool attemptUnknownTypeDeserialization, ITypeConverter typeConverter, ITypeInspector typeInspector, YamlFormatter formatter, INamingConvention enumNamingConvention)
		{
			this.attemptUnknownTypeDeserialization = attemptUnknownTypeDeserialization;
			this.typeConverter = typeConverter ?? throw new ArgumentNullException("typeConverter");
			this.typeInspector = typeInspector;
			this.formatter = formatter;
			this.enumNamingConvention = enumNamingConvention;
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!parser.TryConsume<YamlDotNet.Core.Events.Scalar>(out var @event))
			{
				value = null;
				return false;
			}
			Type type = Nullable.GetUnderlyingType(expectedType) ?? FsharpHelper.GetOptionUnderlyingType(expectedType) ?? expectedType;
			if (type.IsEnum())
			{
				string name = enumNamingConvention.Reverse(@event.Value);
				name = typeInspector.GetEnumName(type, name);
				value = Enum.Parse(type, name, 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, formatter.NumberFormat);
				break;
			case TypeCode.Double:
				value = double.Parse(@event.Value, formatter.NumberFormat);
				break;
			case TypeCode.Decimal:
				value = decimal.Parse(@event.Value, formatter.NumberFormat);
				break;
			case TypeCode.String:
				value = @event.Value;
				break;
			case TypeCode.Char:
				value = @event.Value[0];
				break;
			case TypeCode.DateTime:
				value = DateTime.Parse(@event.Value, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind);
				break;
			default:
				if (expectedType == typeof(object))
				{
					if (!@event.IsKey && attemptUnknownTypeDeserialization)
					{
						value = AttemptUnknownTypeDeserialization(@event);
					}
					else
					{
						value = @event.Value;
					}
				}
				else
				{
					value = typeConverter.ChangeType(@event.Value, expectedType, enumNamingConvention, typeInspector);
				}
				break;
			}
			return true;
		}

		private static bool DeserializeBooleanHelper(string value)
		{
			if (Regex.IsMatch(value, "^(true|y|yes|on)$", RegexOptions.IgnoreCase))
			{
				return true;
			}
			if (Regex.IsMatch(value, "^(false|n|no|off)$", RegexOptions.IgnoreCase))
			{
				return false;
			}
			throw new FormatException("The value \"" + value + "\" is not a valid YAML Boolean");
		}

		private object DeserializeIntegerHelper(TypeCode typeCode, string value)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				int i = 0;
				bool flag = false;
				ulong num = 0uL;
				if (value[0] == '-')
				{
					i++;
					flag = true;
				}
				else if (value[0] == '+')
				{
					i++;
				}
				if (value[i] == '0')
				{
					int num2;
					if (i == value.Length - 1)
					{
						num2 = 10;
						num = 0uL;
					}
					else
					{
						i++;
						if (value[i] == 'b')
						{
							num2 = 2;
							i++;
						}
						else if (value[i] == 'x')
						{
							num2 = 16;
							i++;
						}
						else
						{
							num2 = 8;
						}
					}
					for (; i < value.Length; i++)
					{
						if (value[i] != '_')
						{
							builder.Append(value[i]);
						}
					}
					switch (num2)
					{
					case 2:
					case 8:
						num = Convert.ToUInt64(builder.ToString(), num2);
						break;
					case 16:
						num = ulong.Parse(builder.ToString(), NumberStyles.HexNumber, formatter.NumberFormat);
						break;
					}
				}
				else
				{
					string[] array = value.Substring(i).Split(new char[1] { ':' });
					num = 0uL;
					for (int j = 0; j < array.Length; j++)
					{
						num *= 60;
						num += ulong.Parse(array[j].Replace("_", ""), CultureInfo.InvariantCulture);
					}
				}
				if (!flag)
				{
					return CastInteger(num, typeCode);
				}
				long number = ((num != 9223372036854775808uL) ? checked(-(long)num) : long.MinValue);
				return CastInteger(number, typeCode);
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private static object CastInteger(long number, TypeCode typeCode)
		{
			return checked(typeCode switch
			{
				TypeCode.Byte => (byte)number, 
				TypeCode.Int16 => (short)number, 
				TypeCode.Int32 => (int)number, 
				TypeCode.Int64 => number, 
				TypeCode.SByte => (sbyte)number, 
				TypeCode.UInt16 => (ushort)number, 
				TypeCode.UInt32 => (uint)number, 
				TypeCode.UInt64 => (ulong)number, 
				_ => number, 
			});
		}

		private static object CastInteger(ulong number, TypeCode typeCode)
		{
			return checked(typeCode switch
			{
				TypeCode.Byte => (byte)number, 
				TypeCode.Int16 => (short)number, 
				TypeCode.Int32 => (int)number, 
				TypeCode.Int64 => (long)number, 
				TypeCode.SByte => (sbyte)number, 
				TypeCode.UInt16 => (ushort)number, 
				TypeCode.UInt32 => (uint)number, 
				TypeCode.UInt64 => number, 
				_ => number, 
			});
		}

		private object? AttemptUnknownTypeDeserialization(YamlDotNet.Core.Events.Scalar value)
		{
			if (value.Style == ScalarStyle.SingleQuoted || value.Style == ScalarStyle.DoubleQuoted || value.Style == ScalarStyle.Folded)
			{
				return value.Value;
			}
			string v = value.Value;
			switch (v)
			{
			case "null":
			case "Null":
			case "NULL":
			case "~":
			case "":
				return null;
			case "true":
			case "True":
			case "TRUE":
				return true;
			case "False":
			case "FALSE":
			case "false":
				return false;
			default:
				if (Regex.IsMatch(v, "^0x[0-9a-fA-F]+$"))
				{
					v = v.Substring(2);
					if (byte.TryParse(v, NumberStyles.AllowHexSpecifier, formatter.NumberFormat, out var result))
					{
						return result;
					}
					if (short.TryParse(v, NumberStyles.AllowHexSpecifier, formatter.NumberFormat, out var result2))
					{
						return result2;
					}
					if (int.TryParse(v, NumberStyles.AllowHexSpecifier, formatter.NumberFormat, out var result3))
					{
						return result3;
					}
					if (long.TryParse(v, NumberStyles.AllowHexSpecifier, formatter.NumberFormat, out var result4))
					{
						return result4;
					}
					if (ulong.TryParse(v, NumberStyles.AllowHexSpecifier, formatter.NumberFormat, out var result5))
					{
						return result5;
					}
					return v;
				}
				if (Regex.IsMatch(v, "^0o[0-9a-fA-F]+$"))
				{
					if (!TryAndSwallow(() => Convert.ToByte(v, 8), out object value2) && !TryAndSwallow(() => Convert.ToInt16(v, 8), out value2) && !TryAndSwallow(() => Convert.ToInt32(v, 8), out value2) && !TryAndSwallow(() => Convert.ToInt64(v, 8), out value2) && !TryAndSwallow(() => Convert.ToUInt64(v, 8), out value2))
					{
						return v;
					}
					return value2;
				}
				if (Regex.IsMatch(v, "^[-+]?(\\.[0-9]+|[0-9]+(\\.[0-9]*)?)([eE][-+]?[0-9]+)?$"))
				{
					if (byte.TryParse(v, NumberStyles.Integer, formatter.NumberFormat, out var result6))
					{
						return result6;
					}
					if (short.TryParse(v, NumberStyles.Integer, formatter.NumberFormat, out var result7))
					{
						return result7;
					}
					if (int.TryParse(v, NumberStyles.Integer, formatter.NumberFormat, out var result8))
					{
						return result8;
					}
					if (long.TryParse(v, NumberStyles.Integer, formatter.NumberFormat, out var result9))
					{
						return result9;
					}
					if (ulong.TryParse(v, NumberStyles.Integer, formatter.NumberFormat, out var result10))
					{
						return result10;
					}
					if (float.TryParse(v, NumberStyles.Float, formatter.NumberFormat, out var result11))
					{
						return result11;
					}
					if (double.TryParse(v, NumberStyles.Float, formatter.NumberFormat, out var result12))
					{
						return result12;
					}
					return v;
				}
				if (Regex.IsMatch(v, "^[-+]?(\\.inf|\\.Inf|\\.INF)$"))
				{
					if (Polyfills.StartsWith(v, '-'))
					{
						return float.NegativeInfinity;
					}
					return float.PositiveInfinity;
				}
				if (Regex.IsMatch(v, "^(\\.nan|\\.NaN|\\.NAN)$"))
				{
					return float.NaN;
				}
				return v;
			}
		}

		private static bool TryAndSwallow(Func<object> attempt, out object? value)
		{
			try
			{
				value = attempt();
				return true;
			}
			catch
			{
				value = null;
				return false;
			}
		}
	}
	internal sealed class StaticArrayNodeDeserializer : INodeDeserializer
	{
		private sealed class ArrayList : IList, ICollection, IEnumerable
		{
			private object?[] data;

			public bool IsFixedSize => false;

			public bool IsReadOnly => false;

			public object? this[int index]
			{
				get
				{
					return data[index];
				}
				set
				{
					data[index] = value;
				}
			}

			public int Count { get; private set; }

			public bool IsSynchronized => false;

			public object SyncRoot => data;

			public ArrayList()
			{
				Clear();
			}

			public int Add(object? value)
			{
				if (Count == data.Length)
				{
					Array.Resize(ref data, data.Length * 2);
				}
				data[Count] = value;
				return Count++;
			}

			public void Clear()
			{
				data = new object[10];
				Count = 0;
			}

			bool IList.Contains(object? value)
			{
				throw new NotSupportedException();
			}

			int IList.IndexOf(object? value)
			{
				throw new NotSupportedException();
			}

			void IList.Insert(int index, object? value)
			{
				throw new NotSupportedException();
			}

			void IList.Remove(object? value)
			{
				throw new NotSupportedException();
			}

			void IList.RemoveAt(int index)
			{
				throw new NotSupportedException();
			}

			public void CopyTo(Array array, int index)
			{
				Array.Copy(data, 0, array, index, Count);
			}

			public IEnumerator GetEnumerator()
			{
				int i = 0;
				while (i < Count)
				{
					yield return data[i];
					int num = i + 1;
					i = num;
				}
			}
		}

		private readonly StaticObjectFactory factory;

		public StaticArrayNodeDeserializer(StaticObjectFactory factory)
		{
			this.factory = factory ?? throw new ArgumentNullException("factory");
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!factory.IsArray(expectedType))
			{
				value = false;
				return false;
			}
			Type valueType = factory.GetValueType(expectedType);
			ArrayList arrayList = new ArrayList();
			StaticCollectionNodeDeserializer.DeserializeHelper(valueType, parser, nestedObjectDeserializer, arrayList, factory);
			Array array = factory.CreateArray(expectedType, arrayList.Count);
			arrayList.CopyTo(array, 0);
			value = array;
			return true;
		}
	}
	internal sealed class StaticCollectionNodeDeserializer : INodeDeserializer
	{
		private readonly StaticObjectFactory factory;

		public StaticCollectionNodeDeserializer(StaticObjectFactory factory)
		{
			this.factory = factory ?? throw new ArgumentNullException("factory");
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!factory.IsList(expectedType))
			{
				value = null;
				return false;
			}
			DeserializeHelper(result: (IList)(value = factory.Create(expectedType) as IList), tItem: factory.GetValueType(expectedType), parser: parser, nestedObjectDeserializer: nestedObjectDeserializer, factory: factory);
			return true;
		}

		internal static void DeserializeHelper(Type tItem, IParser parser, Func<IParser, Type, object?> nestedObjectDeserializer, IList result, IObjectFactory factory)
		{
			IList result2 = result;
			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)
				{
					int index = result2.Add(factory.CreatePrimitive(tItem));
					valuePromise.ValueAvailable += delegate(object? v)
					{
						result2[index] = v;
					};
				}
				else
				{
					result2.Add(obj);
				}
			}
		}
	}
	internal class StaticDictionaryNodeDeserializer : DictionaryDeserializer, INodeDeserializer
	{
		private readonly StaticObjectFactory objectFactory;

		public StaticDictionaryNodeDeserializer(StaticObjectFactory objectFactory, bool duplicateKeyChecking)
			: base(duplicateKeyChecking)
		{
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
		}

		public bool Deserialize(IParser reader, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (objectFactory.IsDictionary(expectedType))
			{
				if (!(objectFactory.Create(expectedType) is IDictionary dictionary))
				{
					value = null;
					return false;
				}
				Type keyType = objectFactory.GetKeyType(expectedType);
				Type valueType = objectFactory.GetValueType(expectedType);
				value = dictionary;
				base.Deserialize(keyType, valueType, reader, nestedObjectDeserializer, dictionary, rootDeserializer);
				return true;
			}
			value = null;
			return false;
		}
	}
	internal sealed class TypeConverterNodeDeserializer : INodeDeserializer
	{
		private readonly TypeConverterCache converters;

		public TypeConverterNodeDeserializer(IEnumerable<IYamlTypeConverter> converters)
		{
			this.converters = new TypeConverterCache(converters);
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!converters.TryGetConverterForType(expectedType, out IYamlTypeConverter typeConverter))
			{
				value = null;
				return false;
			}
			value = typeConverter.ReadYaml(parser, expectedType, rootDeserializer);
			return true;
		}
	}
	internal sealed class YamlConvertibleNodeDeserializer : INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		public YamlConvertibleNodeDeserializer(IObjectFactory objectFactory)
		{
			this.objectFactory = objectFactory;
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			Func<IParser, Type, object?> nestedObjectDeserializer2 = nestedObjectDeserializer;
			IParser parser2 = parser;
			if (typeof(IYamlConvertible).IsAssignableFrom(expectedType))
			{
				IYamlConvertible yamlConvertible = (IYamlConvertible)objectFactory.Create(expectedType);
				yamlConvertible.Read(parser2, expectedType, (Type type) => nestedObjectDeserializer2(parser2, type));
				value = yamlConvertible;
				return true;
			}
			value = null;
			return false;
		}
	}
	internal sealed class YamlSerializableNodeDeserializer : INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		public YamlSerializableNodeDeserializer(IObjectFactory objectFactory)
		{
			this.objectFactory = objectFactory;
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (typeof(IYamlSerializable).IsAssignableFrom(expectedType))
			{
				IYamlSerializable yamlSerializable = (IYamlSerializable)objectFactory.Create(expectedType);
				yamlSerializable.ReadYaml(parser);
				value = yamlSerializable;
				return true;
			}
			value = null;
			return false;
		}
	}
}
namespace YamlDotNet.Serialization.NamingConventions
{
	internal sealed class CamelCaseNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new CamelCaseNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public CamelCaseNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return value.ToCamelCase();
		}

		public string Reverse(string value)
		{
			return value.ToPascalCase();
		}
	}
	internal sealed class HyphenatedNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new HyphenatedNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public HyphenatedNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return value.FromCamelCase("-");
		}

		public string Reverse(string value)
		{
			return value.ToPascalCase();
		}
	}
	internal sealed class LowerCaseNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new LowerCaseNamingConvention();

		private LowerCaseNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return value.ToCamelCase().ToLower(CultureInfo.InvariantCulture);
		}

		public string Reverse(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return value;
			}
			return char.ToUpperInvariant(value[0]) + value.Substring(1);
		}
	}
	internal sealed class NullNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new NullNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public NullNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return value;
		}

		public string Reverse(string value)
		{
			return value;
		}
	}
	internal sealed class PascalCaseNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new PascalCaseNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public PascalCaseNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return value.ToPascalCase();
		}

		public string Reverse(string value)
		{
			return value.ToPascalCase();
		}
	}
	internal sealed class UnderscoredNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new UnderscoredNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public UnderscoredNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return value.FromCamelCase("_");
		}

		public string Reverse(string value)
		{
			return value.ToPascalCase();
		}
	}
}
namespace YamlDotNet.Serialization.EventEmitters
{
	internal abstract class ChainedEventEmitter : IEventEmitter
	{
		protected readonly IEventEmitter nextEmitter;

		protected ChainedEventEmitter(IEventEmitter nextEmitter)
		{
			this.nextEmitter = nextEmitter ?? throw new ArgumentNullException("nextEmitter");
		}

		public virtual void Emit(AliasEventInfo eventInfo, IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(ScalarEventInfo eventInfo, IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(MappingStartEventInfo eventInfo, IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(MappingEndEventInfo eventInfo, IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(SequenceStartEventInfo eventInfo, IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(SequenceEndEventInfo eventInfo, IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}
	}
	internal sealed class JsonEventEmitter : ChainedEventEmitter
	{
		private readonly YamlFormatter formatter;

		private readonly INamingConvention enumNamingConvention;

		private readonly ITypeInspector typeInspector;

		public JsonEventEmitter(IEventEmitter nextEmitter, YamlFormatter formatter, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
			: base(nextEmitter)
		{
			this.formatter = formatter;
			this.enumNamingConvention = enumNamingConvention;
			this.typeInspector = typeInspector;
		}

		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 = formatter.FormatBoolean(value);
					break;
				case TypeCode.SByte:
				case TypeCode.Byte:
				case TypeCode.Int16:
				case TypeCode.UInt16:
				case TypeCode.Int32:
				case TypeCode.UInt32:
				case TypeCode.Int64:
				case TypeCode.UInt64:
					if (eventInfo.Source.Type.IsEnum())
					{
						eventInfo.RenderedValue = formatter.FormatEnum(value, typeInspector, enumNamingConvention);
						eventInfo.Style = ((!formatter.PotentiallyQuoteEnums(value)) ? ScalarStyle.Plain : ScalarStyle.DoubleQuoted);
					}
					else
					{
						eventInfo.RenderedValue = formatter.FormatNumber(value);
					}
					break;
				case TypeCode.Single:
				{
					float f = (float)value;
					eventInfo.RenderedValue = f.ToString("G", CultureInfo.InvariantCulture);
					if (float.IsNaN(f) || float.IsInfinity(f))
					{
						eventInfo.Style = ScalarStyle.DoubleQuoted;
					}
					break;
				}
				case TypeCode.Double:
				{
					double d = (double)value;
					eventInfo.RenderedValue = d.ToString("G", CultureInfo.InvariantCulture);
					if (double.IsNaN(d) || double.IsInfinity(d))
					{
						eventInfo.Style = ScalarStyle.DoubleQuoted;
					}
					break;
				}
				case TypeCode.Decimal:
					eventInfo.RenderedValue = ((decimal)value).ToString(CultureInfo.InvariantCulture);
					break;
				case TypeCode.Char:
				case TypeCode.String:
					eventInfo.RenderedValue = value.ToString();
					eventInfo.Style = ScalarStyle.DoubleQuoted;
					break;
				case TypeCode.DateTime:
					eventInfo.RenderedValue = formatter.FormatDateTime(value);
					break;
				case TypeCode.Empty:
					eventInfo.RenderedValue = "null";
					break;
				default:
					if (eventInfo.Source.Type == typeof(TimeSpan))
					{
						eventInfo.RenderedValue = formatter.FormatTimeSpan(value);
						break;
					}
					throw new NotSupportedException($"TypeCode.{typeCode} is not supported.");
				}
			}
			base.Emit(eventInfo, emitter);
		}

		public override void Emit(MappingStartEventInfo eventInfo, IEmitter emitter)
		{
			eventInfo.Style = MappingStyle.Flow;
			base.Emit(eventInfo, emitter);
		}

		public override void Emit(SequenceStartEventInfo eventInfo, IEmitter emitter)
		{
			eventInfo.Style = SequenceStyle.Flow;
			base.Emit(eventInfo, emitter);
		}
	}
	internal sealed class TypeAssigningEventEmitter : ChainedEventEmitter
	{
		private readonly IDictionary<Type, TagName> tagMappings;

		private readonly bool quoteNecessaryStrings;

		private readonly Regex? isSpecialStringValue_Regex;

		private static readonly string SpecialStrings_Pattern = "^(null|Null|NULL|\\~|true|True|TRUE|false|False|FALSE|[-+]?[0-9]+|0o[0-7]+|0x[0-9a-fA-F]+|[-+]?(\\.[0-9]+|[0-9]+(\\.[0-9]*)?)([eE][-+]?[0-9]+)?|[-+]?(\\.inf|\\.Inf|\\.INF)|\\.nan|\\.NaN|\\.NAN|\\s.*)$";

		private static readonly string CombinedYaml1_1SpecialStrings_Pattern = "^(null|Null|NULL|\\~|true|True|TRUE|false|False|FALSE|y|Y|yes|Yes|YES|n|N|no|No|NO|on|On|ON|off|Off|OFF|[-+]?0b[0-1_]+|[-+]?0o?[0-7_]+|[-+]?(0|[1-9][0-9_]*)|[-+]?0x[0-9a-fA-F_]+|[-+]?[1-9][0-9_]*(:[0-5]?[0-9])+|[-+]?([0-9][0-9_]*)?\\.[0-9_]*([eE][-+][0-9]+)?|[-+]?[0-9][0-9_]*(:[0-5]?[0-9])+\\.[0-9_]*|[-+]?\\.(inf|Inf|INF)|\\.(nan|NaN|NAN))$";

		private readonly ScalarStyle defaultScalarStyle;

		private readonly YamlFormatter formatter;

		private readonly INamingConvention enumNamingConvention;

		private readonly ITypeInspector typeInspector;

		public TypeAssigningEventEmitter(IEventEmitter nextEmitter, IDictionary<Type, TagName> tagMappings, bool quoteNecessaryStrings, bool quoteYaml1_1Strings, ScalarStyle defaultScalarStyle, YamlFormatter formatter, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
			: base(nextEmitter)
		{
			this.defaultScalarStyle = defaultScalarStyle;
			this.formatter = formatter;
			this.tagMappings = tagMappings;
			this.quoteNecessaryStrings = quoteNecessaryStrings;
			isSpecialStringValue_Regex = new Regex(quoteYaml1_1Strings ? CombinedYaml1_1SpecialStrings_Pattern : SpecialStrings_Pattern, RegexOptions.Compiled);
			this.enumNamingConvention = enumNamingConvention;
			this.typeInspector = typeInspector;
		}

		public override void Emit(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 = formatter.FormatBoolean(value);
					break;
				case TypeCode.SByte:
				case TypeCode.Byte:
				case TypeCode.Int16:
				case TypeCode.UInt16:
				case TypeCode.Int32:
				case TypeCode.UInt32:
				case TypeCode.Int64:
				case TypeCode.UInt64:
					if (eventInfo.Source.Type.IsEnum)
					{
						eventInfo.Tag = FailsafeSchema.Tags.Str;
						eventInfo.RenderedValue = formatter.FormatEnum(value, typeInspector, enumNamingConvention);
						style = ((!quoteNecessaryStrings || !IsSpecialStringValue(eventInfo.RenderedValue) || !formatter.PotentiallyQuoteEnums(value)) ? defaultScalarStyle : ScalarStyle.DoubleQuoted);
					}
					else
					{
						eventInfo.Tag = JsonSchema.Tags.Int;
						eventInfo.RenderedValue = formatter.FormatNumber(value);
					}
					break;
				case TypeCode.Single:
					eventInfo.Tag = JsonSchema.Tags.Float;
					eventInfo.RenderedValue = formatter.FormatNumber((float)value);
					break;
				case TypeCode.Double:
					eventInfo.Tag = JsonSchema.Tags.Float;
					eventInfo.RenderedValue = formatter.FormatNumber((double)value);
					break;
				case TypeCode.Decimal:
					eventInfo.Tag = JsonSchema.Tags.Float;
					eventInfo.RenderedValue = formatter.FormatNumber(value);
					break;
				case TypeCode.Char:
				case TypeCode.String:
					eventInfo.Tag = FailsafeSchema.Tags.Str;
					eventInfo.RenderedValue = value.ToString();
					style = ((!quoteNecessaryStrings || !IsSpecialStringValue(eventInfo.RenderedValue)) ? defaultScalarStyle : ScalarStyle.DoubleQuoted);
					break;
				case TypeCode.DateTime:
					eventInfo.Tag = DefaultSchema.Tags.Timestamp;
					eventInfo.RenderedValue = formatter.FormatDateTime(value);
					break;
				case TypeCode.Empty:
					eventInfo.Tag = JsonSchema.Tags.Null;
					eventInfo.RenderedValue = "";
					break;
				default:
					if (eventInfo.Source.Type == typeof(TimeSpan))
					{
						eventInfo.RenderedValue = formatter.FormatTimeSpan(value);
						break;
					}
					throw new NotSupportedException($"TypeCode.{typeCode} is not supported.");
				}
			}
			eventInfo.IsPlainImplicit = true;
			if (eventInfo.Style == 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;
			}
		}

		private bool IsSpecialStringValue(string value)
		{
			if (value.Trim() == string.Empty)
			{
				return true;
			}
			return isSpecialStringValue_Regex?.IsMatch(value) ?? false;
		}
	}
	internal sealed class WriterEventEmitter : IEventEmitter
	{
		void IEventEmitter.Emit(AliasEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new YamlDotNet.Core.Events.AnchorAlias(eventInfo.Alias));
		}

		void IEventEmitter.Emit(ScalarEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(eventInfo.Anchor, eventInfo.Tag, eventInfo.RenderedValue, eventInfo.Style, eventInfo.IsPlainImplicit, eventInfo.IsQuotedImplicit));
		}

		void IEventEmitter.Emit(MappingStartEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new MappingStart(eventInfo.Anchor, eventInfo.Tag, eventInfo.IsImplicit, eventInfo.Style));
		}

		void IEventEmitter.Emit(MappingEndEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new MappingEnd());
		}

		void IEventEmitter.Emit(SequenceStartEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new SequenceStart(eventInfo.Anchor, eventInfo.Tag, eventInfo.IsImplicit, eventInfo.Style));
		}

		void IEventEmitter.Emit(SequenceEndEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new SequenceEnd());
		}
	}
}
namespace YamlDotNet.Serialization.Converters
{
	internal class DateTime8601Converter : IYamlTypeConverter
	{
		private readonly ScalarStyle scalarStyle;

		public DateTime8601Converter()
			: this(ScalarStyle.Any)
		{
		}

		public DateTime8601Converter(ScalarStyle scalarStyle)
		{
			this.scalarStyle = scalarStyle;
		}

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

		public object ReadYaml(IParser parser, Type type, ObjectDeserializer rootDeserializer)
		{
			string value = parser.Consume<YamlDotNet.Core.Events.Scalar>().Value;
			DateTime dateTime = DateTime.ParseExact(value, "O", CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind);
			return dateTime;
		}

		public void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer)
		{
			string value2 = ((DateTime)value).ToString("O", CultureInfo.InvariantCulture);
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, value2, scalarStyle, isPlainImplicit: true, isQuotedImplicit: false));
		}
	}
	internal class DateTimeConverter : IYamlTypeConverter
	{
		private readonly DateTimeKind kind;

		private readonly IFormatProvider provider;

		private readonly bool doubleQuotes;

		private readonly string[] formats;

		public DateTimeConverter(DateTimeKind kind = DateTimeKind.Utc, IFormatProvider? provider = null, bool doubleQuotes = false, params string[] formats)
		{
			this.kind = ((kind == DateTimeKind.Unspecified) ? DateTimeKind.Utc : kind);
			this.provider = provider ?? CultureInfo.InvariantCulture;
			this.doubleQuotes = doubleQuotes;
			this.formats = formats.DefaultIfEmpty("G").ToArray();
		}

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

		public object ReadYaml(IParser parser, Type type, ObjectDeserializer rootDeserializer)
		{
			string value = parser.Consume<YamlDotNet.Core.Events.Scalar>().Value;
			DateTimeStyles style = ((kind == DateTimeKind.Local) ? DateTimeStyles.AssumeLocal : DateTimeStyles.AssumeUniversal);
			DateTime dt = DateTime.ParseExact(value, formats, provider, style);
			dt = EnsureDateTimeKind(dt, kind);
			return dt;
		}

		public void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer)
		{
			DateTime dateTime = (DateTime)value;
			string value2 = ((kind == DateTimeKind.Local) ? dateTime.ToLocalTime() : dateTime.ToUniversalTime()).ToString(formats.First(), provider);
			emitter.Emit(new YamlDotNet.Core.Events.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;
		}
	}
	internal class DateTimeOffsetConverter : IYamlTypeConverter
	{
		private readonly IFormatProvider provider;

		private readonly ScalarStyle style;

		private readonly DateTimeStyles dateStyle;

		private readonly string[] formats;

		public DateTimeOffsetConverter(IFormatProvider? provider = null, ScalarStyle style = ScalarStyle.Any, DateTimeStyles dateStyle = DateTimeStyles.None, params string[] formats)
		{
			this.provider = provider ?? CultureInfo.InvariantCulture;
			this.style = style;
			this.dateStyle = dateStyle;
			this.formats = formats.DefaultIfEmpty("O").ToArray();
		}

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

		public object ReadYaml(IParser parser, Type type, ObjectDeserializer rootDeserializer)
		{
			string value = parser.Consume<YamlDotNet.Core.Events.Scalar>().Value;
			DateTimeOffset dateTimeOffset = DateTimeOffset.ParseExact(value, formats, provider, dateStyle);
			return dateTimeOffset;
		}

		public void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer)
		{
			string value2 = ((DateTimeOffset)value).ToString(formats.First(), provider);
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, value2, style, isPlainImplicit: true, isQuotedImplicit: false));
		}
	}
	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, ObjectDeserializer rootDeserializer)
		{
			string value = parser.Consume<YamlDotNet.Core.Events.Scalar>().Value;
			return new Guid(value);
		}

		public void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer)
		{
			Guid guid = (Guid)value;
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, guid.ToString("D"), jsonCompatible ? ScalarStyle.DoubleQuoted : ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: false));
		}
	}
	internal class SystemTypeConverter : IYamlTypeConverter
	{
		public bool Accepts(Type type)
		{
			return typeof(Type).IsAssignableFrom(type);
		}

		public object ReadYaml(IParser parser, Type type, ObjectDeserializer rootDeserializer)
		{
			string value = parser.Consume<YamlDotNet.Core.Events.Scalar>().Value;
			return Type.GetType(value, throwOnError: true);
		}

		public void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer)
		{
			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.Callbacks
{
	[AttributeUsage(AttributeTargets.Method)]
	internal sealed class OnDeserializedAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method)]
	internal sealed class OnDeserializingAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method)]
	internal sealed class OnSerializedAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method)]
	internal sealed class OnSerializingAttribute : Attribute
	{
	}
}
namespace YamlDotNet.Serialization.BufferedDeserialization
{
	internal interface ITypeDiscriminatingNodeDeserializerOptions
	{
		void AddTypeDiscriminator(ITypeDiscriminator discriminator);

		void AddKeyValueTypeDiscriminator<T>(string discriminatorKey, IDictionary<string, Type> valueTypeMapping);

		void AddUniqueKeyTypeDiscriminator<T>(IDictionary<string, Type> uniqueKeyTypeMapping);
	}
	internal class ParserBuffer : IParser
	{
		private readonly LinkedList<ParsingEvent> buffer;

		private LinkedListNode<ParsingEvent>? current;

		public ParsingEvent? Current => current?.Value;

		public ParserBuffer(IParser parserToBuffer, int maxDepth, int maxLength)
		{
			buffer = new LinkedList<ParsingEvent>();
			buffer.AddLast(parserToBuffer.Consume<MappingStart>());
			int num = 0;
			do
			{
				ParsingEvent parsingEvent = parserToBuffer.Consume<ParsingEvent>();
				num += parsingEvent.NestingIncrease;
				buffer.AddLast(parsingEvent);
				if (maxDepth > -1 && num > maxDepth)
				{
					throw new ArgumentOutOfRangeException("parserToBuffer", "Parser buffer exceeded max depth");
				}
				if (maxLength > -1 && buffer.Count > maxLength)
				{
					throw new ArgumentOutOfRangeException("parserToBuffer", "Parser buffer exceeded max length");
				}
			}
			while (num >= 0);
			current = buffer.First;
		}

		public bool MoveNext()
		{
			current = current?.Next;
			return current != null;
		}

		public void Reset()
		{
			current = buffer.First;
		}
	}
	internal class TypeDiscriminatingNodeDeserializer : INodeDeserializer
	{
		private readonly IList<INodeDeserializer> innerDeserializers;

		private readonly IList<ITypeDiscriminator> typeDiscriminators;

		private readonly int maxDepthToBuffer;

		private readonly int maxLengthToBuffer;

		public TypeDiscriminatingNodeDeserializer(IList<INodeDeserializer> innerDeserializers, IList<ITypeDiscriminator> typeDiscriminators, int maxDepthToBuffer, int maxLengthToBuffer)
		{
			this.innerDeserializers = innerDeserializers;
			this.typeDiscriminators = typeDiscriminators;
			this.maxDepthToBuffer = maxDepthToBuffer;
			this.maxLengthToBuffer = maxLengthToBuffer;
		}

		public bool Deserialize(IParser reader, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			Type expectedType2 = expectedType;
			if (!reader.Accept<MappingStart>(out var _))
			{
				value = null;
				return false;
			}
			IEnumerable<ITypeDiscriminator> enumerable = typeDiscriminators.Where((ITypeDiscriminator t) => t.BaseType.IsAssignableFrom(expectedType2));
			if (!enumerable.Any())
			{
				value = null;
				return false;
			}
			Mark start = reader.Current.Start;
			Type expectedType3 = expectedType2;
			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 Type suggestedType))
					{
						expectedType3 = 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, expectedType3, nestedObjectDeserializer, out value, rootDeserializer))
				{
					return true;
				}
			}
			value = null;
			return false;
		}
	}
	internal class TypeDiscriminatingNodeDeserializerOptions : ITypeDiscriminatingNodeDeserializerOptions
	{
		internal readonly List<ITypeDiscriminator> discriminators = new List<ITypeDiscriminator>();

		public void AddTypeDiscriminator(ITypeDiscriminator discriminator)
		{
			discriminators.Add(discriminator);
		}

		public void AddKeyValueTypeDiscriminator<T>(string discriminatorKey, IDictionary<string, Type> valueTypeMapping)
		{
			discriminators.Add(new KeyValueTypeDiscriminator(typeof(T), discriminatorKey, valueTypeMapping));
		}

		public void AddUniqueKeyTypeDiscriminator<T>(IDictionary<string, Type> uniqueKeyTypeMapping)
		{
			discriminators.Add(new UniqueKeyTypeDiscriminator(typeof(T), uniqueKeyTypeMapping));
		}
	}
}
namespace YamlDotNet.Serialization.BufferedDeserialization.TypeDiscriminators
{
	internal interface ITypeDiscriminator
	{
		Type BaseType { get; }

		bool TryDiscriminate(IParser buffer, out Type? suggestedType);
	}
	internal class KeyValueTypeDiscriminator : ITypeDiscriminator
	{
		private readonly string targetKey;

		private readonly IDictionary<string, Type> typeMapping;

		public Type BaseType { get; private set; }

		public KeyValueTypeDiscriminator(Type baseType, string targetKey, IDictionary<string, Type> typeMapping)
		{
			foreach (KeyValuePair<string, Type> item in typeMapping)
			{
				if (!baseType.IsAssignableFrom(item.Value))
				{
					throw new ArgumentOutOfRangeException("typeMapping", $"{item.Value} is not a assignable to {baseType}");
				}
			}
			BaseType = baseType;
			this.targetKey = targetKey;
			this.typeMapping = typeMapping;
		}

		public bool TryDiscriminate(IParser parser, out Type? suggestedType)
		{
			if (parser.TryFindMappingEntry((YamlDotNet.Core.Events.Scalar scalar) => targetKey == scalar.Value, out YamlDotNet.Core.Events.Scalar _, out ParsingEvent value) && value is YamlDotNet.Core.Events.Scalar scalar2 && typeMapping.TryGetValue(scalar2.Value, out Type value2))
			{
				suggestedType = value2;
				return true;
			}
			suggestedType = null;
			return false;
		}
	}
	internal class UniqueKeyTypeDiscriminator : ITypeDiscriminator
	{
		private readonly IDictionary<string, Type> typeMapping;

		public Type BaseType { get; private set; }

		public UniqueKeyTypeDiscriminator(Type baseType, IDictionary<string, Type> typeMapping)
		{
			foreach (KeyValuePair<string, Type> item in typeMapping)
			{
				if (!baseType.IsAssignableFrom(item.Value))
				{
					throw new ArgumentOutOfRangeException("typeMapping", $"{item.Value} is not a assignable to {baseType}");
				}
			}
			BaseType = baseType;
			this.typeMapping = typeMapping;
		}

		public bool TryDiscriminate(IParser parser, out Type? suggestedType)
		{
			if (parser.TryFindMappingEntry((YamlDotNet.Core.Events.Scalar scalar) => typeMapping.ContainsKey(scalar.Value), out YamlDotNet.Core.Events.Scalar key, out ParsingEvent _))
			{
				suggestedType = typeMapping[key.Value];
				return true;
			}
			suggestedType = null;
			return false;
		}
	}
}
namespace YamlDotNet.RepresentationModel
{
	internal class DocumentLoadingState
	{
		private readonly Dictionary<AnchorName, YamlNode> anchors = new Dictionary<AnchorName, YamlNode>();

		private readonly List<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");
			}
			anchors[node.Anchor] = node;
		}

		public YamlNode GetNode(AnchorName anchor, Mark start, Mark end)
		{
			if (anchors.TryGetValue(anchor, out YamlNode value))
			{
				return value;
			}
			throw new AnchorNotFoundException(in start, in end, $"The anchor '{anchor}' does not exists");
		}

		public bool TryGetNode(AnchorName anchor, [NotNullWhen(true)] out YamlNode? node)
		{
			return anchors.TryGetValue(anchor, out node);
		}

		public void AddNodeWithUnresolvedAliases(YamlNode node)
		{
			nodesWithUnresolvedAliases.Add(node);
		}

		public void ResolveAliases()
		{
			foreach (YamlNode nodesWithUnresolvedAlias in nodesWithUnresolvedAliases)
			{
				nodesWithUnresolvedAlias.ResolveAliases(this);
			}
		}
	}
	internal class EmitterState
	{
		public HashSet<AnchorName> EmittedAnchors { get; } = new HashSet<AnchorName>();

	}
	internal interface IYamlVisitor
	{
		void Visit(YamlStream stream);

		void Visit(YamlDocument document);

		void Visit(YamlScalarNode scalar);

		void Visit(YamlSequenceNode sequence);

		void Visit(YamlMappingNode mapping);
	}
	internal class LibYamlEventStream
	{
		private readonly IParser parser;

		public LibYamlEventStream(IParser iParser)
		{
			parser = iParser ?? throw new ArgumentNullException("iParser");
		}

		public void WriteTo(TextWriter textWriter)
		{
			while (parser.MoveNext())
			{
				ParsingEvent current = parser.Current;
				if (!(current is YamlDotNet.Core.Events.AnchorAlias anchorAlias))
				{
					if (!(current is YamlDotNet.Core.Events.DocumentEnd documentEnd))
					{
						if (!(current is YamlDotNet.Core.Events.DocumentStart documentStart))
						{
							if (!(current is MappingEnd))
							{
								if (!(current is MappingStart nodeEvent))
								{
									if (!(current is YamlDotNet.Core.Events.Scalar scalar))
									{
										if (!(current is SequenceEnd))
										{
											if (!(current is SequenceStart nodeEvent2))
											{
												if (!(current is YamlDotNet.Core.Events.StreamEnd))
												{
													if (current is YamlDotNet.Core.Events.StreamStart)
													{
														textWriter.Write("+STR");
													}
												}
												else
												{
													textWriter.Write("-STR");
												}
											}
											else
											{
												textWriter.Write("+SEQ");
												WriteAnchorAndTag(textWriter, nodeEvent2);
											}
										}
										else
										{
											textWriter.Write("-SEQ");
										}
									}
									else
									{
										textWriter.Write("=VAL");
										WriteAnchorAndTag(textWriter, scalar);
										switch (scalar.Style)
										{
										case ScalarStyle.DoubleQuoted:
											textWriter.Write(" \"");
											break;
										case ScalarStyle.SingleQuoted:
											textWriter.Write(" '");
											break;
										case ScalarStyle.Folded:
											textWriter.Write(" >");
											break;
										case ScalarStyle.Literal:
											textWriter.Write(" |");
											break;
										default:
											textWriter.Write(" :");
											break;
										}
										string value = scalar.Value;
										foreach (char c in value)
										{
											switch (c)
											{
											case '\b':
												textWriter.Write("\\b");
												break;
											case '\t':
												textWriter.Write("\\t");
												break;
											case '\n':
												textWriter.Write("\\n");
												break;
											case '\r':
												textWriter.Write("\\r");
												break;
											case '\\':
												textWriter.Write("\\\\");
												break;
											default:
												textWriter.Write(c);
												break;
											}
										}
									}
								}
								else
								{
									textWriter.Write("+MAP");
									WriteAnchorAndTag(textWriter, nodeEvent);
								}
							}
							else
							{
								textWriter.Write("-MAP");
							}
						}
						else
						{
							textWriter.Write("+DOC");
							if (!documentStart.IsImplicit)
							{
								textWriter.Write(" ---");
							}
						}
					}
					else
					{
						textWriter.Write("-DOC");
						if (!documentEnd.IsImplicit)
						{
							textWriter.Write(" ...");
						}
					}
				}
				else
				{
					textWriter.Write("=ALI *");
					textWriter.Write(anchorAlias.Value);
				}
				textWriter.WriteLine();
			}
		}

		private static void WriteAnchorAndTag(TextWriter textWriter, NodeEvent nodeEvent)
		{
			if (!nodeEvent.Anchor.IsEmpty)
			{
				textWriter.Write(" &");
				textWriter.Write(nodeEvent.Anchor);
			}
			if (!nodeEvent.Tag.IsEmpty)
			{
				textWriter.Write(" <");
				textWriter.Write(nodeEvent.Tag.Value);
				textWriter.Write(">");
			}
		}
	}
	internal class YamlAliasNode : YamlNode
	{
		public override YamlNodeType NodeType => YamlNodeType.Alias;

		internal YamlAliasNode(AnchorName anchor)
		{
			base.Anchor = anchor;
		}

		internal override void ResolveAliases(DocumentLoadingState state)
		{
			throw new NotSupportedException("Resolving an alias on an alias node does not make sense");
		}

		internal override void Emit(IEmitter emitter, EmitterState state)
		{
			throw new NotSupportedException("A YamlAliasNode is an implementation detail and should never be saved.");
		}

		public override void Accept(IYamlVisitor visitor)
		{
			throw new NotSupportedException("A YamlAliasNode is an implementation detail and should never be visited.");
		}

		public override bool Equals(object? obj)
		{
			if (obj is YamlAliasNode yamlAliasNode && Equals(yamlAliasNode))
			{
				return object.Equals(base.Anchor, yamlAliasNode.Anchor);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return base.GetHashCode();
		}

		internal override string ToString(RecursionLevel level)
		{
			return "*" + base.Anchor;
		}

		internal override IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level)
		{
			yield return this;
		}
	}
	internal class YamlDocument
	{
		private class AnchorAssigningVisitor : YamlVisitorBase
		{
			private readonly HashSet<AnchorName> existingAnchors = new HashSet<AnchorName>();

			private readonly Dictionary<YamlNode, bool> visitedNodes = new Dictionary<YamlNode, bool>();

			public void AssignAnchors(YamlDocument document)
			{
				existingAnchors.Clear();
				visitedNodes.Clear();
				document.Accept(this);
				Random random = new Random();
				foreach (KeyValuePair<YamlNode, bool> visitedNode in visitedNodes)
				{
					if (!visitedNode.Value)
					{
						continue;
					}
					AnchorName anchorName;
					if (!visitedNode.Key.Anchor.IsEmpty && !existingAnchors.Contains(visitedNode.Key.Anchor))
					{
						anchorName = visitedNode.Key.Anchor;
					}
					else
					{
						do
						{
							anchorName = new AnchorName(random.Next().ToString(CultureInfo.InvariantCulture));
						}
						while (existingAnchors.Contains(anchorName));
					}
					existingAnchors.Add(anchorName);
					visitedNode.Key.Anchor = anchorName;
				}
			}

			private bool VisitNodeAndFindDuplicates(YamlNode node)
			{
				if (visitedNodes.TryGetValue(node, out var value))
				{
					if (!value)
					{
						visitedNodes[node] = true;
					}
					return !value;
				}
				visitedNodes.Add(node, value: false);
				return false;
			}

			public override void Visit(YamlScalarNode scalar)
			{
				VisitNodeAndFindDuplicates(scalar);
			}

			public override void Visit(YamlMappingNode mapping)
			{
				if (!VisitNodeAndFindDuplicates(mapping))
				{
					base.Visit(mapping);
				}
			}

			public override void Visit(YamlSequenceNode sequence)
			{
				if (!VisitNodeAndFindDuplicates(sequence))
				{
					base.Visit(sequence);
				}
			}
		}

		public YamlNode RootNode { get; private set; }

		public IEnumerable<YamlNode> AllNodes => RootNode.AllNodes;

		public YamlDocument(YamlNode rootNode)
		{
			RootNode = rootNode;
		}

		public YamlDocument(string rootNode)
		{
			RootNode = new YamlScalarNode(rootNode);
		}

		internal YamlDocument(IParser parser)
		{
			DocumentLoadingState documentLoadingState = new DocumentLoadingState();
			parser.Consume<YamlDotNet.Core.Events.DocumentStart>();
			YamlDotNet.Core.Events.DocumentEnd @event;
			while (!parser.TryConsume<YamlDotNet.Core.Events.DocumentEnd>(out @event))
			{
				RootNode = YamlNode.ParseNode(parser, documentLoadingState);
				if (RootNode is YamlAliasNode)
				{
					throw new YamlException("A document cannot contain only an alias");
				}
			}
			documentLoadingState.ResolveAliases();
			if (RootNode == null)
			{
				throw new ArgumentException("Atempted to parse an empty document");
			}
		}

		private void AssignAnchors()
		{
			AnchorAssigningVisitor anchorAssigningVisitor = new AnchorAssigningVisitor();
			anchorAssigningVisitor.AssignAnchors(this);
		}

		internal void Save(IEmitter emitter, bool assignAnchors = true)
		{
			if (assignAnchors)
			{
				AssignAnchors();
			}
			emitter.Emit(new YamlDotNet.Core.Events.DocumentStart());
			RootNode.Save(emitter, new EmitterState());
			emitter.Emit(new YamlDotNet.Core.Events.DocumentEnd(isImplicit: false));
		}

		public void Accept(IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal sealed class YamlMappingNode : YamlNode, IEnumerable<KeyValuePair<YamlNode, YamlNode>>, IEnumerable, IYamlConvertible
	{
		private readonly 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);
				if (!children.TryAdd(yamlNode, yamlNode2))
				{
					Mark start = yamlNode.Start;
					Mark end = yamlNode.End;
					throw new YamlException(in start, in end, $"Duplicate key {yamlNode}");
				}
				flag = flag || yamlNode is YamlAliasNode || yamlNode2 is YamlAliasNode;
			}
			if (flag)
			{
				state.AddNodeWithUnresolvedAliases(this);
			}
		}

		public YamlMappingNode()
		{
		}

		public YamlMappingNode(params KeyValuePair<YamlNode, YamlNode>[] children)
			: this((IEnumerable<KeyValuePair<YamlNode, YamlNode>>)children)
		{
		}

		public YamlMappingNode(IEnumerable<KeyValuePair<YamlNode, YamlNode>> children)
		{
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				this.children.Add(child);
			}
		}

		public YamlMappingNode(params YamlNode[] children)
			: this((IEnumerable<YamlNode>)children)
		{
		}

		public YamlMappingNode(IEnumerable<YamlNode> children)
		{
			using IEnumerator<YamlNode> enumerator = children.GetEnumerator();
			while (enumerator.MoveNext())
			{
				YamlNode current = enumerator.Current;
				if (!enumerator.MoveNext())
				{
					throw new ArgumentException("When constructing a mapping node with a sequence, the number of elements of the sequence must be even.");
				}
				Add(current, enumerator.Current);
			}
		}

		public void Add(YamlNode key, YamlNode value)
		{
			children.Add(key, value);
		}

		public void Add(string key, YamlNode value)
		{
			children.Add(new YamlScalarNode(key), value);
		}

		public void Add(YamlNode key, string value)
		{
			children.Add(key, new YamlScalarNode(value));
		}

		public void Add(string key, string value)
		{
			children.Add(new YamlScalarNode(key), new YamlScalarNode(value));
		}

		internal override void ResolveAliases(DocumentLoadingState state)
		{
			Dictionary<YamlNode, YamlNode> dictionary = null;
			Dictionary<YamlNode, YamlNode> dictionary2 = null;
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				if (child.Key is YamlAliasNode)
				{
					if (dictionary == null)
					{
						dictionary = new Dictionary<YamlNode, YamlNode>();
					}
					dictionary.Add(child.Key, state.GetNode(child.Key.Anchor, child.Key.Start, child.Key.End));
				}
				if (child.Value is YamlAliasNode)
				{
					if (dictionary2 == null)
					{
						dictionary2 = new Dictionary<YamlNode, YamlNode>();
					}
					dictionary2.Add(child.Key, state.GetNode(child.Value.Anchor, child.Value.Start, child.Value.End));
				}
			}
			if (dictionary2 != null)
			{
				foreach (KeyValuePair<YamlNode, YamlNode> item in dictionary2)
				{
					children[item.Key] = item.Value;
				}
			}
			if (dictionary == null)
			{
				return;
			}
			foreach (KeyValuePair<YamlNode, YamlNode> item2 in dictionary)
			{
				YamlNode value = children[item2.Key];
				children.Remove(item2.Key);
				children.Add(item2.Value, value);
			}
		}

		internal override void Emit(IEmitter emitter, EmitterState state)
		{
			emitter.Emit(new MappingStart(base.Anchor, base.Tag, isImplicit: true, Style));
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				child.Key.Save(emitter, state);
				child.Value.Save(emitter, state);
			}
			emitter.Emit(new MappingEnd());
		}

		public override void Accept(IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override bool Equals(object? obj)
		{
			if (!(obj is YamlMappingNode yamlMappingNode) || !object.Equals(base.Tag, yamlMappingNode.Tag) || children.Count != yamlMappingNode.children.Count)
			{
				return false;
			}
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				if (!yamlMappingNode.children.TryGetValue(child.Key, out YamlNode value) || !object.Equals(child.Value, value))
				{
					return false;
				}
			}
			return true;
		}

		public override int GetHashCode()
		{
			int num = base.GetHashCode();
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				num = YamlDotNet.Core.HashCode.CombineHashCodes(num, child.Key);
				num = (child.Value.Anchor.IsEmpty ? YamlDotNet.Core.HashCode.CombineHashCodes(num, child.Value) : YamlDotNet.Core.HashCode.CombineHashCodes(num, child.Value.Anchor));
			}
			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();
			}
		}

		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)
					{
						string text = Convert.ToString(value, CultureInfo.InvariantCulture);
						yamlNode = text ?? string.Empty;
					}
					yamlMappingNode.Add(publicProperty.Name, yamlNode);
				}
			}
			return yamlMappingNode;
		}
	}
	internal abstract class YamlNode
	{
		private const int MaximumRecursionLevel = 1000;

		internal const string MaximumRecursionLevelReachedToStringValue = "WARNING! INFINITE RECURSION!";

		public AnchorName Anchor { get; set; }

		public TagName Tag { get; set; }

		public Mark Start { get; private set; } = Mark.Empty;


		public Mark End { get; private set; } = Mark.Empty;


		public IEnumerable<YamlNode> AllNodes
		{
			get
			{
				RecursionLevel level = new RecursionLevel(1000);
				return SafeAllNodes(level);
			}
		}

		public abstract YamlNodeType NodeType { get; }

		public YamlNode this[int index]
		{
			get
			{
				if (!(this is YamlSequenceNode yamlSequenceNode))
				{
					throw new ArgumentException($"Accessed '{NodeType}' with an invalid index: {index}. Only Sequences can be indexed by number.");
				}
				return yamlSequenceNode.Children[index];
			}
		}

		public YamlNode this[YamlNode key]
		{
			get
			{
				if (!(this is YamlMappingNode yamlMappingNode))
				{
					throw new ArgumentException($"Accessed '{NodeType}' with an invalid index: {key}. Only Mappings can be indexed by key.");
				}
				return yamlMappingNode.Children[key];
			}
		}

		internal void Load(NodeEvent yamlEvent, DocumentLoadingState state)
		{
			Tag = yamlEvent.Tag;
			if (!yamlEvent.Anchor.IsEmpty)
			{
				Anchor = yamlEvent.Anchor;
				state.AddAnchor(this);
			}
			Start = yamlEvent.Start;
			End = yamlEvent.End;
		}

		internal static YamlNode ParseNode(IParser parser, DocumentLoadingState state)
		{
			if (parser.Accept<YamlDotNet.Core.Events.Scalar>(out var _))
			{
				return new YamlScalarNode(parser, state);
			}
			if (parser.Accept<SequenceStart>(out var _))
			{
				return new YamlSequenceNode(parser, state);
			}
			if (parser.Accept<MappingStart>(out var _))
			{
				return new YamlMappingNode(parser, state);
			}
			if (parser.TryConsume<YamlDotNet.Core.Events.AnchorAlias>(out var event4))
			{
				if (!state.TryGetNode(event4.Value, out YamlNode node))
				{
					return new YamlAliasNode(event4.Value);
				}
				return node;
			}
			throw new ArgumentException("The current event is of an unsupported type.", "parser");
		}

		internal abstract void ResolveAliases(DocumentLoadingState state);

		internal void Save(IEmitter emitter, EmitterState state)
		{
			if (!Anchor.IsEmpty && !state.EmittedAnchors.Add(Anchor))
			{
				emitter.Emit(new YamlDotNet.Core.Events.AnchorAlias(Anchor));
			}
			else
			{
				Emit(emitter, state);
			}
		}

		internal abstract void Emit(IEmitter emitter, EmitterState state);

		public abstract void Accept(IYamlVisitor visitor);

		public override string ToString()
		{
			RecursionLevel recursionLevel = new RecursionLevel(1000);
			return ToString(recursionLevel);
		}

		internal abstract string ToString(RecursionLevel level);

		internal abstract IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level);

		public static implicit operator YamlNode(string value)
		{
			return new YamlScalarNode(value);
		}

		public static implicit operator YamlNode(string[] sequence)
		{
			return new YamlSequenceNode(((IEnumerable<string>)sequence).Select((Func<string, YamlNode>)((string i) => i)));
		}

		public static explicit operator string?(YamlNode node)
		{
			if (!(node is YamlScalarNode yamlScalarNode))
			{
				throw new ArgumentException($"Attempted to convert a '{node.NodeType}' to string. This conversion is valid only for Scalars.");
			}
			return yamlScalarNode.Value;
		}
	}
	internal sealed class YamlNodeIdentityEqualityComparer : IEqualityComparer<YamlNode>
	{
		public bool Equals([AllowNull] YamlNode x, [AllowNull] YamlNode y)
		{
			return x == y;
		}

		public int GetHashCode(YamlNode obj)
		{
			return obj.GetHashCode();
		}
	}
	internal enum YamlNodeType
	{
		Alias,
		Mapping,
		Scalar,
		Sequence
	}
	[DebuggerDisplay("{Value}")]
	internal sealed class YamlScalarNode : YamlNode, IYamlConvertible
	{
		private bool forceImplicitPlain;

		private string? value;

		public string? Value
		{
			get
			{
				return value;
			}
			set
			{
				if (value == null)
				{
					forceImplicitPlain = true;
				}
				else
				{
					forceImplicitPlain = false;
				}
				this.value = value;
			}
		}

		public ScalarStyle Style { get; set; }

		public override YamlNodeType NodeType => YamlNodeType.Scalar;

		internal YamlScalarNode(IParser parser, DocumentLoadingState state)
		{
			Load(parser, state);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private void Load(IParser parser, DocumentLoadingState state)
		{
			YamlDotNet.Core.Events.Scalar scalar = parser.Consume<YamlDotNet.Core.Events.Scalar>();
			Load(scalar, state);
			string text = scalar.Value;
			if (scalar.Style == ScalarStyle.Plain && base.Tag.IsEmpty)
			{
				forceImplicitPlain = text.Length switch
				{
					0 => true, 
					1 => text == "~", 
					4 => text == "null" || text == "Null" || text == "NULL", 
					_ => false, 
				};
			}
			value = text;
			Style = scalar.Style;
		}

		public YamlScalarNode()
		{
		}

		public YamlScalarNode(string? value)
		{
			Value = value;
		}

		internal override void ResolveAliases(DocumentLoadingState state)
		{
			throw new NotSupportedException("Resolving an alias on a scalar node does not make sense");
		}

		internal override void Emit(IEmitter emitter, EmitterState state)
		{
			TagName tag = base.Tag;
			bool isPlainImplicit = tag.IsEmpty;
			if (forceImplicitPlain && Style == ScalarStyle.Plain && (Value == null || Value == ""))
			{
				tag = JsonSchema.Tags.Null;
				isPlainImplicit = true;
			}
			else if (tag.IsEmpty && Value == null && (Style == ScalarStyle.Plain || Style == ScalarStyle.Any))
			{
				tag = JsonSchema.Tags.Null;
				isPlainImplicit = true;
			}
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(base.Anchor, tag, Value ?? string.Empty, Style, isPlainImplicit, isQuotedImplicit: false));
		}

		public override void Accept(IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override bool Equals(object? obj)
		{
			if (obj is YamlScalarNode yamlScalarNode && object.Equals(base.Tag, yamlScalarNode.Tag))
			{
				return object.Equals(Value, yamlScalarNode.Value);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return YamlDotNet.Core.HashCode.CombineHashCodes(base.Tag.GetHashCode(), Value);
		}

		public static explicit operator string?(YamlScalarNode value)
		{
			return value.Value;
		}

		internal override string ToString(RecursionLevel level)
		{
			return Value ?? string.Empty;
		}

		internal override IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level)
		{
			yield return this;
		}

		void IYamlConvertible.Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer)
		{
			Load(parser, new DocumentLoadingState());
		}

		void IYamlConvertible.Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer)
		{
			Emit(emitter, new EmitterState());
		}
	}
	[DebuggerDisplay("Count = {children.Count}")]
	internal sealed class YamlSequenceNode : YamlNode, IEnumerable<YamlNode>, IEnumerable, IYamlConvertible
	{
		private readonly List<YamlNode> children = new List<YamlNode>();

		public IList<YamlNode> Children => children;

		public SequenceStyle Style { get; set; }

		public override YamlNodeType NodeType => YamlNodeType.Sequence;

		internal YamlSequenceNode(IParser parser, DocumentLoadingState state)
		{
			Load(parser, state);
		}

		private void Load(IParser parser, DocumentLoadingState state)
		{
			SequenceStart sequenceStart = parser.Consume<SequenceStart>();
			Load(sequenceStart, state);
			Style = sequenceStart.Style;
			bool flag = false;
			SequenceEnd @event;
			while (!parser.TryConsume<SequenceEnd>(out @event))
			{
				YamlNode yamlNode = YamlNode.ParseNode(parser, state);
				children.Add(yamlNode);
				flag = flag || yamlNode is YamlAliasNode;
			}
			if (flag)
			{
				state.AddNodeWithUnresolvedAliases(this);
			}
		}

		public YamlSequenceNode()
		{
		}

		public YamlSequenceNode(params YamlNode[] children)
			: this((IEnumerable<YamlNode>)children)
		{
		}

		public YamlSequenceNode(IEnumerable<YamlNode> children)
		{
			foreach (YamlNode child in children)
			{
				this.children.Add(child);
			}
		}

		public void Add(YamlNode child)
		{
			children.Add(child);
		}

		public void Add(string child)
		{
			children.Add(new YamlScalarNode(child));
		}

		internal override void ResolveAliases(DocumentLoadingState state)
		{
			for (int i = 0; i < children.Count; i++)
			{
				if (children[i] is YamlAliasNode)
				{
					children[i] = state.GetNode(children[i].Anchor, children[i].Start, children[i].End);
				}
			}
		}

		internal override void Emit(IEmitter emitter, EmitterState state)
		{
			emitter.Emit(new SequenceStart(base.Anchor, base.Tag, base.Tag.IsEmpty, Style));
			foreach (YamlNode child in children)
			{
				child.Save(emitter, state);
			}
			emitter.Emit(new SequenceEnd());
		}

		public override void Accept(IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override bool Equals(object? obj)
		{
			if (!(obj is YamlSequenceNode yamlSequenceNode) || !object.Equals(base.Tag, yamlSequenceNode.Tag) || children.Count != yamlSequenceNode.children.Count)
			{
				return false;
			}
			for (int i = 0; i < children.Count; i++)
			{
				if (!object.Equals(children[i], yamlSequenceNode.children[i]))
				{
					return false;
				}
			}
			return true;
		}

		public override int GetHashCode()
		{
			int h = 0;
			foreach (YamlNode child in children)
			{
				h = YamlDotNet.Core.HashCode.CombineHashCodes(h, child);
			}
			return YamlDotNet.Core.HashCode.CombineHashCodes(h, base.Tag);
		}

		internal override IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level)
		{
			level.Increment();
			yield return this;
			foreach (YamlNode child in children)
			{
				foreach (YamlNode item in child.SafeAllNodes(level))
				{
					yield return item;
				}
			}
			level.Decrement();
		}

		internal override string ToString(RecursionLevel level)
		{
			if (!level.TryIncrement())
			{
				return "WARNING! INFINITE RECURSION!";
			}
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				builder.Append("[ ");
				foreach (YamlNode child in children)
				{
					if (builder.Length > 2)
					{
						builder.Append(", ");
					}
					builder.Append(child.ToString(level));
				}
				builder.Append(" ]");
				level.Decrement();
				return builder.ToString();
			}
			finally
			{
				((IDisposable)builderWrapper).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());
		}
	}
	internal class YamlStream : IEnumerable<YamlDocument>, IEnumerable
	{
		private readonly List<YamlDocument> documents = new List<YamlDocument>();

		public IList<YamlDocument> Documents => documents;

		public YamlStream()
		{
		}

		public YamlStream(params YamlDocument[] documents)
			: this((IEnumerable<YamlDocument>)documents)
		{
		}

		public YamlStream(IEnumerable<YamlDocument> documents)
		{
			foreach (YamlDocument document in documents)
			{
				this.documents.Add(document);
			}
		}

		public void Add(YamlDocument document)
		{
			documents.Add(document);
		}

		public void Load(TextReader input)
		{
			Load(new Parser(input));
		}

		public void Load(IParser parser)
		{
			documents.Clear();
			parser.Consume<YamlDotNet.Core.Events.StreamStart>();
			YamlDotNet.Core.Events.StreamEnd @event;
			while (!parser.TryConsume<YamlDotNet.Core.Events.StreamEnd>(out @event))
			{
				YamlDocument item = new YamlDocument(parser);
				documents.Add(item);
			}
		}

		public void Save(TextWriter output)
		{
			Save(output, assignAnchors: true);
		}

		public void Save(TextWriter output, bool assignAnchors)
		{
			Save(new Emitter(output), assignAnchors);
		}

		public void Save(IEmitter emitter, bool assignAnchors)
		{
			emitter.Emit(new YamlDotNet.Core.Events.StreamStart());
			foreach (YamlDocument document in documents)
			{
				document.Save(emitter, assignAnchors);
			}
			emitter.Emit(new YamlDotNet.Core.Events.StreamEnd());
		}

		public void Accept(IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		public IEnumerator<YamlDocument> GetEnumerator()
		{
			return documents.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	[Obsolete("Use YamlVisitorBase")]
	internal abstract class YamlVisitor : IYamlVisitor
	{
		protected virtual void Visit(YamlStream stream)
		{
		}

		protected virtual void Visited(YamlStream stream)
		{
		}

		protected virtual void Visit(YamlDocument document)
		{
		}

		protected virtual void Visited(YamlDocument document)
		{
		}

		protected virtual void Visit(YamlScalarNode scalar)
		{
		}

		protected virtual void Visited(YamlScalarNode scalar)
		{
		}

		protected virtual void Visit(YamlSequenceNode sequence)
		{
		}

		protected virtual void Visited(YamlSequenceNode sequence)
		{
		}

		protected virtual void Visit(YamlMappingNode mapping)
		{
		}

		protected virtual void Visited(YamlMappingNode mapping)
		{
		}

		protected virtual void VisitChildren(YamlStream stream)
		{
			foreach (YamlDocument document in stream.Documents)
			{
				document.Accept(this);
			}
		}

		protected virtual void VisitChildren(YamlDocument document)
		{
			if (document.RootNode != null)
			{
				document.RootNode.Accept(this);
			}
		}

		protected virtual void VisitChildren(YamlSequenceNode sequence)
		{
			foreach (YamlNode child in sequence.Children)
			{
				child.Accept(this);
			}
		}

		protected virtual void VisitChildren(YamlMappingNode mapping)
		{
			foreach (KeyValuePair<YamlNode, YamlNode> child in mapping.Children)
			{
				child.Key.Accept(this);
				child.Value.Accept(this);
			}
		}

		void IYamlVisitor.Visit(YamlStream stream)
		{
			Visit(stream);
			VisitChildren(stream);
			Visited(stream);
		}

		void IYamlVisitor.Visit(YamlDocument document)
		{
			Visit(document);
			VisitChildren(document);
			Visited(document);
		}

		void IYamlVisitor.Visit(YamlScalarNode scalar)
		{
			Visit(scalar);
			Visited(scalar);
		}

		void IYamlVisitor.Visit(YamlSequenceNode sequence)
		{
			Visit(sequence);
			VisitChildren(sequence);
			Visited(sequence);
		}

		void IYamlVisitor.Visit(YamlMappingNode mapping)
		{
			Visit(mapping);
			VisitChildren(mapping);
			Visited(mapping);
		}
	}
	internal abstract class YamlVisitorBase : IYamlVisitor
	{
		public virtual void Visit(YamlStream stream)
		{
			VisitChildren(stream);
		}

		public virtual void Visit(YamlDocument document)
		{
			VisitChildren(document);
		}

		public virtual void Visit(YamlScalarNode scalar)
		{
		}

		public virtual void Visit(YamlSequenceNode sequence)
		{
			VisitChildren(sequence);
		}

		public virtual void Visit(YamlMappingNode mapping)
		{
			VisitChildren(mapping);
		}

		protected virtual void VisitPair(YamlNode key, YamlNode value)
		{
			key.Accept(this);
			value.Accept(this);
		}

		protected virtual void VisitChildren(YamlStream stream)
		{
			foreach (YamlDocument document in stream.Documents)
			{
				document.Accept(this);
			}
		}

		protected virtual void VisitChildren(YamlDocument document)
		{
			if (document.RootNode != null)
			{
				document.RootNode.Accept(this);
			}
		}

		protected virtual void VisitChildren(YamlSequenceNode sequence)
		{
			foreach (YamlNode child in sequence.Children)
			{
				child.Accept(this);
			}
		}

		protected virtual void VisitChildren(YamlMappingNode mapping)
		{
			foreach (KeyValuePair<YamlNode, YamlNode> child in mapping.Children)
			{
				VisitPair(child.Key, child.Value);
			}
		}
	}
}
namespace YamlDotNet.Helpers
{
	internal class DefaultFsharpHelper : IFsharpHelper
	{
		private static bool IsFsharpCore(Type t)
		{
			return t.Namespace == "Microsoft.FSharp.Core";
		}

		public bool IsOptionType(Type t)
		{
			if (IsFsharpCore(t))
			{
				return t.Name == "FSharpOption`1";
			}
			return false;
		}

		public Type? GetOptionUnderlyingType(Type t)
		{
			if (!t.IsGenericType || !IsOptionType(t))
			{
				return null;
			}
			return t.GenericTypeArguments[0];
		}

		public object? GetValue(IObjectDescriptor objectDescriptor)
		{
			if (!IsOptionType(objectDescriptor.Type))
			{
				throw new InvalidOperationException("Should not be called on non-Option<> type");
			}
			if (objectDescriptor.Value == null)
			{
				return null;
			}
			return objectDescriptor.Type.GetProperty("Value").GetValue(objectDescriptor.Value);
		}

		public bool IsFsharpListType(Type t)
		{
			if (t.Namespace == "Microsoft.FSharp.Collections")
			{
				return t.Name == "FSharpList`1";
			}
			return false;
		}

		public object? CreateFsharpListFromArray(Type t, Type itemsType, Array arr)
		{
			if (!IsFsharpListType(t))
			{
				return null;
			}
			return t.Assembly.GetType("Microsoft.FSharp.Collections.ListModule").GetMethod("OfArray").MakeGenericMethod(itemsType)
				.Invoke(null, new object[1] { arr });
		}
	}
	internal static class DictionaryExtensions
	{
		public static bool TryAdd<T, V>(this Dictionary<T, V> dictionary, T key, V value)
		{
			if (dictionary.ContainsKey(key))
			{
				return false;
			}
			dictionary.Add(key, value);
			return true;
		}

		public static TValue GetOrAdd<TKey, TValue, TArg>(this ConcurrentDictionary<TKey, TValue> dictionary, TKey key, Func<TKey, TArg, TValue> valueFactory, TArg arg)
		{
			if (dictionary == null)
			{
				throw new ArgumentNullException("dictionary");
			}
			if (key == null)
			{
				throw new ArgumentNullException("key");
			}
			if (valueFactory == null)
			{
				throw new ArgumentNullException("valueFactory");
			}
			TValue value;
			do
			{
				if (dictionary.TryGetValue(key, out value))
				{
					return value;
				}
				value = valueFactory(key, arg);
			}
			while (!dictionary.TryAdd(key, value));
			return value;
		}
	}
	internal static class ExpressionExtensions
	{
		public static PropertyInfo AsProperty(this LambdaExpression propertyAccessor)
		{
			PropertyInfo propertyInfo = TryGetMemberExpression<PropertyInfo>(propertyAccessor);
			if (propertyInfo == null)
			{
				throw new ArgumentException("Expected a lambda expression in the form: x => x.SomeProperty", "propertyAccessor");
			}
			return propertyInfo;
		}

		[return: MaybeNull]
		private static TMemberInfo TryGetMemberExpression<TMemberInfo>(LambdaExpression lambdaExpression) where TMemberInfo : MemberInfo
		{
			if (lambdaExpression.Parameters.Count != 1)
			{
				return null;
			}
			Expression expression = lambdaExpression.Body;
			if (expression is UnaryExpression unaryExpression)
			{
				if (unaryExpression.NodeType != ExpressionType.Convert)
				{
					return null;
				}
				expression = unaryExpression.Operand;
			}
			if (expression is MemberExpression memberExpression)
			{
				if (memberExpression.Expression != lambdaExpression.Parameters[0])
				{
					return null;
				}
				return memberExpression.Member as TMemberInfo;
			}
			return null;
		}
	}
	internal static class FsharpHelper
	{
		public static IFsharpHelper? Instance { get; set; }

		public static bool IsOptionType(Type t)
		{
			return Instance?.IsOptionType(t) ?? false;
		}

		public static Type? GetOptionUnderlyingType(Type t)
		{
			return Instance?.GetOptionUnderlyingType(t);
		}

		public static object? GetValue(IObjectDescriptor objectDescriptor)
		{
			return Instance?.GetValue(objectDescriptor);
		}

		public static bool IsFsharpListType(Type t)
		{
			return Instance?.IsFsharpListType(t) ?? false;
		}

		public static object? CreateFsharpListFromArray(Type t, Type itemsType, Array arr)
		{
			return Instance?.CreateFsharpListFromArray(t, itemsType, arr);
		}
	}
	internal sealed class GenericCollectionToNonGenericAdapter<T> : IList, ICollection, IEnumerable
	{
		private readonly ICollection<T> genericCollection;

		public bool IsFixedSize
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public bool IsReadOnly
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public object? this[int index]
		{
			get
			{
				throw new NotSupportedException();
			}
			set
			{
				((IList<T>)genericCollection)[index] = (T)value;
			}
		}

		public int Count
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public bool IsSynchronized
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public object SyncRoot
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public GenericCollectionToNonGenericAdapter(ICollection<T> genericCollection)
		{
			this.genericCollection = genericCollection ?? throw new ArgumentNullException("genericCollection");
		}

		public int Add(object? value)
		{
			int count = genericCollection.Count;
			genericCollection.Add((T)value);
			return count;
		}

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

		public bool Contains(object? value)
		{
			throw new NotSupportedException();
		}

		public int IndexOf(object? value)
		{
			throw new NotSupportedException();
		}

		public void Insert(int index, object? value)
		{
			throw new NotSupportedException();
		}

		public void Remove(object? value)
		{
			throw new NotSupportedException();
		}

		public void RemoveAt(int index)
		{
			throw new NotSupportedException();
		}

		public void CopyTo(Array array, int index)
		{
			throw new NotSupportedException();
		}

		public IEnumerator GetEnumerator()
		{
			return genericCollection.GetEnumerator();
		}
	}
	internal sealed class GenericDictionaryToNonGenericAdapter<TKey, TValue> : IDictionary, ICollection, IEnumerable where TKey : notnull
	{
		private class DictionaryEnumerator : IDictionaryEnumerator, IEnumerator
		{
			private readonly IEnumerator<KeyValuePair<TKey, TValue>> enumerator;

			public DictionaryEntry Entry => new DictionaryEntry(Key, Value);

			public object Key => enumerator.Current.Key;

			public object? Value => enumerator.Current.Value;

			public object Current => Entry;

			public DictionaryEnumerator(IEnumerator<KeyValuePair<TKey, TValue>> enumerator)
			{
				this.enumerator = enumerator;
			}

			public bool MoveNext()
			{
				return enumerator.MoveNext();
			}

			public void Reset()
			{
				enumerator.Reset();
			}
		}

		private readonly IDictionary<TKey, TValue> genericDictionary;

		public bool IsFixedSize
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public bool IsReadOnly
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public ICollection Keys
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public ICollection Values
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public object? this[object key]
		{
			get
			{
				throw new NotSupportedException();
			}
			set
			{
				genericDictionary[(TKey)key] = (TValue)value;
			}
		}

		public int Count
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public bool IsSynchronized
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public object SyncRoot
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public GenericDictionaryToNonGenericAdapter(IDictionary<TKey, TValue> genericDictionary)
		{
			this.genericDictionary = genericDictionary ?? throw new ArgumentNullException("genericDictionary");
		}

		public void Add(object key, object? value)
		{
			throw new NotSupportedException();
		}

		public void Clear()
		{
			throw new NotSupportedException();
		}

		public bool Contains(object key)
		{
			throw new NotSupportedException();
		}

		public IDictionaryEnumerator GetEnumerator()
		{
			return new DictionaryEnumerator(genericDictionary.GetEnumerator());
		}

		public void Remove(object key)
		{
			throw new NotSupportedException();
		}

		public void CopyTo(Array array, int index)
		{
			throw new NotSupportedException();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	internal interface IFsharpHelper
	{
		bool IsOptionType(Type t);

		Type? GetOptionUnderlyingType(Type t);

		object? GetValue(IObjectDescriptor objectDescriptor);

		bool IsFsharpListType(Type t);

		object? CreateFsharpListFromArray(Type t, Type itemsType, Array arr);
	}
	internal interface IOrderedDictionary<TKey, TValue> : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable where TKey : notnull
	{
		KeyValuePair<TKey, TValue> this[int index] { get; set; }

		void Insert(int index, TKey key, TValue value);

		void RemoveAt(int index);
	}
	internal class NullFsharpHelper : IFsharpHelper
	{
		public object? CreateFsharpListFromArray(Type t, Type itemsType, Array arr)
		{
			return null;
		}

		public Type? GetOptionUnderlyingType(Type t)
		{
			return null;
		}

		public object? GetValue(IObjectDescriptor objectDescriptor)
		{
			return null;
		}

		public bool IsFsharpListType(Type t)
		{
			return false;
		}

		public bool IsOptionType(Type t)
		{
			return false;
		}
	}
	internal static class NumberExtensions
	{
		public static bool IsPowerOfTwo(this int value)
		{
			return (value & (value - 1)) == 0;
		}
	}
	[Serializable]
	internal sealed class OrderedDictionary<TKey, TValue> : IOrderedDictionary<TKey, TValue>, IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable where TKey : notnull
	{
		private class KeyCollection : ICollection<TKey>, IEnumerable<TKey>, IEnumerable
		{
			private readonly OrderedDictionary<TKey, TValue> orderedDictionary;

			public int Count => orderedDictionary.list.Count;

			public bool IsReadOnly => true;

			public void Add(TKey item)
			{
				throw new NotSupportedException();
			}

			public void Clear()
			{
				throw new NotSupportedException();
			}

			public bool Contains(TKey item)
			{
				return orderedDictionary.dictionary.ContainsKey(item);
			}

			public KeyCollection(OrderedDictionary<TKey, TValue> orderedDictionary)
			{
				this.orderedDictionary = orderedDictionary;
			}

			public void CopyTo(TKey[] array, int arrayIndex)
			{
				for (int i = 0; i < orderedDictionary.list.Count; i++)
				{
					array[i] = orderedDictionary.list[i + arrayIndex].Key;
				}
			}

			public IEnumerator<TKey> GetEnumerator()
			{
				return orderedDictionary.list.Select((KeyValuePair<TKey, TValue> kvp) => kvp.Key).GetEnumerator();
			}

			public bool Remove(TKey item)
			{
				throw new NotSupportedException();
			}

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

		private class ValueCollection : ICollection<TValue>, IEnumerable<TValue>, IEnumerable
		{
			private readonly OrderedDictionary<TKey, TValue> orderedDictionary;

			public int Count => orderedDictionary.list.Count;

			public bool IsReadOnly => true;

			public void Add(TValue item)
			{
				throw new NotSupportedException();
			}

			public void Clear()
			{
				throw new NotSupportedException();
			}

			public bool Contains(TValue item)
			{
				return orderedDictionary.dictionary.ContainsValue(item);
			}

			public ValueCollection(OrderedDictionary<TKey, TValue> orderedDictionary)
			{
				this.orderedDictionary = orderedDictionary;
			}

			public void CopyTo(TValue[] array, int arrayIndex)
			{
				for (int i = 0; i < orderedDictionary.list.Count; i++)
				{
					array[i] = orderedDictionary.list[i + arrayIndex].Value;
				}
			}

			public IEnumerator<TValue> GetEnumerator()
			{
				return orderedDictionary.list.Select((KeyValuePair<TKey, TValue> kvp) => kvp.Value).GetEnumerator();
			}

			public bool Remove(TValue item)
			{
				throw new NotSupportedException();
			}

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

		[NonSerialized]
		private Dictionary<TKey, TValue> dictionary;

		private readonly List<KeyValuePair<TKey, TValue>> list;

		private readonly IEqualityComparer<TKey> comparer;

		public TValue this[TKey key]
		{
			get
			{
				return dictionary[key];
			}
			set
			{
				TKey key2 = key;
				if (dictionary.ContainsKey(key2))
				{
					int index = list.FindIndex((KeyValuePair<TKey, TValue> kvp) => comparer.Equals(kvp.Key, key2));
					dictionary[key2] = value;
					list[index] = new KeyValuePair<TKey, TValue>(key2, value);
				}
				else
				{
					Add(key2, value);
				}
			}
		}

		public ICollection<TKey> Keys => new KeyCollection(this);

		public ICollection<TValue> Values => new ValueCollection(this);

		public int Count => dictionary.Count;

		public bool IsReadOnly => false;

		public KeyValuePair<TKey, TValue> this[int index]
		{
			get
			{
				return list[index];
			}
			set
			{
				list[index] = value;
			}
		}

		public OrderedDictionary()
			: this((IEqualityComparer<TKey>)EqualityComparer<TKey>.Default)
		{
		}

		public OrderedDictionary(IEqualityComparer<TKey> comparer)
		{
			list = new List<KeyValuePair<TKey, TValue>>();
			dictionary = new Dictionary<TKey, TValue>(comparer);
			this.comparer = comparer;
		}

		public void Add(KeyValuePair<TKey, TValue> item)
		{
			if (!TryAdd(item))
			{
				ThrowDuplicateKeyException(item.Key);
			}
		}

		public void Add(TKey key, TValue value)
		{
			if (!TryAdd(key, value))
			{
				ThrowDuplicateKeyException(key);
			}
		}

		private static void ThrowDuplicateKeyException(TKey key)
		{
			throw new ArgumentException($"An item with the same key {key} has already been added.");
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool TryAdd(TKey key, TValue value)
		{
			if (DictionaryExtensions.TryAdd(dictionary, key, value))
			{
				list.Add(new KeyValuePair<TKey, TValue>(key, value));
				return true;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool TryAdd(KeyValuePair<TKey, TValue> item)
		{
			if (DictionaryExtensions.TryAdd(dictionary, item.Key, item.Value))
			{
				list.Add(item);
				return true;
			}
			return false;
		}

		public void Clear()
		{
			dictionary.Clear();
			list.Clear();
		}

		public bool Contains(KeyValuePair<TKey, TValue> item)
		{
			return dictionary.Contains(item);
		}

		public bool ContainsKey(TKey key)
		{
			return dictionary.ContainsKey(key);
		}

		public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
		{
			list.CopyTo(array, arrayIndex);
		}

		public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
		{
			return list.GetEnumerator();
		}

		public void Insert(int index, TKey key, TValue value)
		{
			dictionary.Add(key, value);
			list.Insert(index, new KeyValuePair<TKey, TValue>(key, value));
		}

		public bool Remove(TKey key)
		{
			TKey key2 = key;
			if (dictionary.ContainsKey(key2))
			{
				int index = list.FindIndex((KeyValuePair<TKey, TValue> kvp) => comparer.Equals(kvp.Key, key2));
				list.RemoveAt(index);
				if (!dictionary.Remove(key2))
				{
					throw new InvalidOperationException();
				}
				return true;
			}
			return false;
		}

		public bool Remove(KeyValuePair<TKey, TValue> item)
		{
			return Remove(item.Key);
		}

		public void RemoveAt(int index)
		{
			TKey key = list[index].Key;
			dictionary.Remove(key);
			list.RemoveAt(index);
		}

		public bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value)
		{
			return dictionary.TryGetValue(key, out value);
		}

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

		[System.Runtime.Serialization.OnDeserialized]
		internal void OnDeserializedMethod(StreamingContext context)
		{
			dictionary = new Dictionary<TKey, TValue>();
			foreach (KeyValuePair<TKey, TValue> item in list)
			{
				dictionary[item.Key] = item.Value;
			}
		}
	}
	internal static class ReadOnlyCollectionExtensions
	{
		public static IReadOnlyList<T> AsReadonlyList<T>(this List<T> list)
		{
			return list;
		}

		public static IReadOnlyDictionary<TKey, TValue> AsReadonlyDictionary<TKey, TValue>(this Dictionary<TKey, TValue> dictionary) where TKey : notnull
		{
			return dictionary;
		}
	}
	internal static class ThrowHelper
	{
		[MethodImpl(MethodImplOptions.NoInlining)]
		public static void ThrowArgumentOutOfRangeException(string paramName, string message)
		{
			throw new ArgumentOutOfRangeException(paramName, message);
		}
	}
}
namespace YamlDotNet.Core
{
	internal readonly struct AnchorName : IEquatable<AnchorName>
	{
		public static readonly AnchorName Empty;

		private static readonly Regex AnchorPattern = new Regex("^[^\\[\\]\\{\\},]+$", RegexOptions.Compiled);

		private readonly string? value;

		public string Value => value ?? throw new InvalidOperationException("Cannot read the Value of an empty anchor");

		public bool IsEmpty => value == null;

		public AnchorName(string value)
		{
			this.value = value ?? throw new ArgumentNullException("value");
			if (!AnchorPattern.IsMatch(value))
			{
				throw new ArgumentException("Anchor cannot be empty or contain disallowed characters: []{},\nThe value was '" + value + "'.", "value");
			}
		}

		public override string ToString()
		{
			return value ?? "[empty]";
		}

		public bool Equals(AnchorName other)
		{
			return object.Equals(value, other.value);
		}

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

		public override int GetHashCode()
		{
			return value?.GetHashCode() ?? 0;
		}

		public static bool operator ==(AnchorName left, AnchorName right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(AnchorName left, AnchorName right)
		{
			return !(left == right);
		}

		public static implicit operator AnchorName(string? value)
		{
			if (value != null)
			{
				return new AnchorName(value);
			}
			return Empty;
		}
	}
	internal class AnchorNotFoundException : YamlException
	{
		public AnchorNotFoundException(string message)
			: base(message)
		{
		}

		public AnchorNotFoundException(in Mark start, in Mark end, string message)
			: base(in start, in end, message)
		{
		}

		public AnchorNotFoundException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	[DebuggerStepThrough]
	internal readonly struct CharacterAnalyzer<TBuffer> where TBuffer : ILookAheadBuffer
	{
		public TBuffer Buffer { get; }

		public bool EndOfInput => Buffer.EndOfInput;

		public CharacterAnalyzer(TBuffer buffer)
		{
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer");
			}
			Buffer = buffer;
		}

		public char Peek(int offset)
		{
			return Buffer.Peek(offset);
		}

		public void Skip(int length)
		{
			Buffer.Skip(length);
		}

		public bool IsAlphaNumericDashOrUnderscore(int offset = 0)
		{
			char c = Buffer.Peek(offset);
			if ((c < '0' || c > '9') && (c < 'A' || c > 'Z') && (c < 'a' || c > 'z') && c != '_')
			{
				return c == '-';
			}
			return true;
		}

		public bool IsAscii(int offset = 0)
		{
			return Buffer.Peek(offset) <= '\u007f';
		}

		public bool IsPrintable(int offset = 0)
		{
			char c = Buffer.Peek(offset);
			switch (c)
			{
			default:
				if (c != '\u0085' && (c < '\u00a0' || c > '\ud7ff'))
				{
					if (c >= '\ue000')
					{
						return c <= '\ufffd';
					}
					return false;
				}
				break;
			case '\t':
			case '\n':
			case '\r':
			case ' ':
			case '!':
			case '"':
			case '#':
			case '$':
			case '%':
			case '&':
			case '\'':
			case '(':
			case ')':
			case '*':
			case '+':
			case ',':
			case '-':
			case '.':
			case '/':
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
			case ':':
			case ';':
			case '<':
			case '=':
			case '>':
			case '?':
			case '@':
			case 'A':
			case 'B':
			case 'C':
			case 'D':
			case 'E':
			case 'F':
			case 'G':
			case 'H':
			case 'I':
			case 'J':
			case 'K':
			case 'L':
			case 'M':
			case 'N':
			case 'O':
			case 'P':
			case 'Q':
			case 'R':
			case 'S':
			case 'T':
			case 'U':
			case 'V':
			case 'W':
			case 'X':
			case 'Y':
			case 'Z':
			case '[':
			case '\\':
			case ']':
			case '^':
			case '_':
			case '`':
			case 'a':
			case 'b':
			case 'c':
			case 'd':
			case 'e':
			case 'f':
			case 'g':
			case 'h':
			case 'i':
			case 'j':
			case 'k':
			case 'l':
			case 'm':
			case 'n':
			case 'o':
			case 'p':
			case 'q':
			case 'r':
			case 's':
			case 't':
			case 'u':
			case 'v':
			case 'w':
			case 'x':
			case 'y':
			case 'z':
			case '{':
			case '|':
			case '}':
			case '~':
				break;
			}
			return true;
		}

		public bool IsDigit(int offset = 0)
		{
			char c = Buffer.Peek(offset);
			if (c >= '0')
			{
				return c <= '9';
			}
			return false;
		}

		public int AsDigit(int offset = 0)
		{
			return Buffer.Peek(offset) - 48;
		}

		public bool IsHex(int offset)
		{
			char c = Buffer.Peek(offset);
			if ((c < '0' || c > '9') && (c < 'A' || c > 'F'))
			{
				if (c >= 'a')
				{
					return c <= 'f';
				}
				return false;
			}
			return true;
		}

		public int AsHex(int offset)
		{
			char c = Buffer.Peek(offset);
			if (c <= '9')
			{
				return c - 48;
			}
			if (c <= 'F')
			{
				return c - 65 + 10;
			}
			return c - 97 + 10;
		}

		public bool IsSpace(int offset = 0)
		{
			return Check(' ', offset);
		}

		public bool IsZero(int offset = 0)
		{
			return Check('\0', offset);
		}

		public bool IsTab(int offset = 0)
		{
			return Check('\t', offset);
		}

		public bool IsWhite(int offset = 0)
		{
			if (!IsSpace(offset))
			{
				return IsTab(offset);
			}
			return true;
		}

		public bool IsBreak(int offset = 0)
		{
			return Check("\r\n\u0085\u2028\u2029", offset);
		}

		public bool IsCrLf(int offset = 0)
		{
			if (Check('\r', offset))
			{
				return Check('\n', offset + 1);
			}
			return false;
		}

		public bool IsBreakOrZero(int offset = 0)
		{
			if (!IsBreak(offset))
			{
				return IsZero(offset);
			}
			return true;
		}

		public bool IsWhiteBreakOrZero(int offset = 0)
		{
			if (!IsWhite(offset))
			{
				return IsBreakOrZero(offset);
			}
			return true;
		}

		public bool Check(char expected, int offset = 0)
		{
			return Buffer.Peek(offset) == expected;
		}

		public bool Check(string expectedCharacters, int offset = 0)
		{
			char c = Buffer.Peek(offset);
			return Polyfills.Contains(expectedCharacters, c);
		}
	}
	internal static class Constants
	{
		public static readonly TagDirective[] DefaultTagDirectives = new TagDirective[2]
		{
			new TagDirective("!", "!"),
			new TagDirective("!!", "tag:yaml.org,2002:")
		};

		public const int MajorVersion = 1;

		public const int MinorVersion = 3;
	}
	[DebuggerStepThrough]
	internal sealed class Cursor
	{
		public long Index { get; private set; }

		public long Line { get; private set; }

		public long LineOffset { get; private set; }

		public Cursor()
		{
			Line = 1L;
		}

		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 = 0L;
		}

		public void ForceSkipLineAfterNonBreak()
		{
			if (LineOffset != 0L)
			{
				Line++;
				LineOffset = 0L;
			}
		}
	}
	internal class Emitter : IEmitter
	{
		private class AnchorData
		{
			public AnchorName Anchor;

			public bool IsAlias;
		}

		private class TagData
		{
			public string? Handle;

			public string? Suffix;
		}

		private class ScalarData
		{
			public string Value = string.Empty;

			public bool IsMultiline;

			public bool IsFlowPlainAllowed;

			public bool IsBlockPlainAllowed;

			public bool IsSingleQuotedAllowed;

			public bool IsBlockAllowed;

			public bool HasSingleQuotes;

			public ScalarStyle Style;
		}

		private static readonly Regex UriReplacer = new Regex("[^0-9A-Za-z_\\-;?@=$~\\\\\\)\\]/:&+,\\.\\*\\(\\[!]", RegexOptions.Compiled | RegexOptions.Singleline);

		private static readonly string[] NewLineSeparators = new string[3] { "\r\n", "\r", "\n" };

		private readonly TextWriter output;

		private readonly bool outputUsesUnicodeEncoding;

		private readonly int maxSimpleKeyLength;

		private readonly bool isCanonical;

		private readonly bool skipAnchorName;

		private readonly int bestIndent;

		private readonly int bestWidth;

		private EmitterState state;

		private readonly Stack<EmitterState> states = new Stack<EmitterState>();

		private readonly Queue<ParsingEvent> events = new Queue<ParsingEvent>();

		private readonly Stack<int> indents = new Stack<int>();

		private readonly TagDirectiveCollection tagDirectives = new TagDirectiveCollection();

		private int indent;

		private int flowLevel;

		private bool isMappingContext;

		private bool isSimpleKeyContext;

		private int column;

		private bool isWhitespace;

		private bool isIndentation;

		private readonly bool forceIndentLess;

		private readonly bool useUtf16SurrogatePair;

		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;
			useUtf16SurrogatePair = settings.UseUtf16SurrogatePairs;
			this.output = output;
			this.output.NewLine = settings.NewLine;
			outputUsesUnicodeEncoding = IsUnicode(output.Encoding);
		}

		public void Emit(ParsingEvent @event)
		{
			events.Enqueue(@event);
			while (!NeedMoreEvents())
			{
				ParsingEvent evt = events.Peek();
				try
				{
					AnalyzeEvent(evt);
					StateMachine(evt);
				}
				finally
				{
					events.Dequeue();
				}
			}
		}

		private bool NeedMoreEvents()
		{
			if (events.Count == 0)
			{
				return true;
			}
			int num;
			switch (events.Peek().Type)
			{
			case EventType.DocumentStart:
				num = 1;
				break;
			case EventType.SequenceStart:
				num = 2;
				break;
			case EventType.MappingStart:
				num = 3;
				break;
			default:
				return false;
			}
			if (events.Count > num)
			{
				return false;
			}
			int num2 = 0;
			foreach (ParsingEvent @event in events)
			{
				switch (@event.Type)
				{
				case EventType.DocumentStart:
				case EventType.SequenceStart:
				case EventType.MappingStart:
					num2++;
					break;
				case EventType.DocumentEnd:
				case EventType.SequenceEnd:
				case EventType.MappingEnd:
					num2--;
					break;
				}
				if (num2 == 0)
				{
					return false;
				}
			}
			return true;
		}

		private void AnalyzeEvent(ParsingEvent evt)
		{
			anchorData.Anchor = AnchorName.Empty;
			tagData.Handle = null;
			tagData.Suffix = null;
			if (evt is YamlDotNet.Core.Events.AnchorAlias anchorAlias)
			{
				AnalyzeAnchor(anchorAlias.Value, isAlias: true);
			}
			else if (evt is NodeEvent nodeEvent)
			{
				if (evt is YamlDotNet.Core.Events.Scalar scalar)
				{
					AnalyzeScalar(scalar);
				}
				AnalyzeAnchor(nodeEvent.Anchor, isAlias: false);
				if (!nodeEvent.Tag.IsEmpty && (isCanonical || nodeEvent.IsCanonical))
				{
					AnalyzeTag(nodeEvent.Tag);
				}
			}
		}

		private void AnalyzeAnchor(AnchorName anchor, bool isAlias)
		{
			anchorData.Anchor = anchor;
			anchorData.IsAlias = isAlias;
		}

		private void AnalyzeScalar(YamlDotNet.Core.Events.Scalar scalar)
		{
			string value = scalar.Value;
			scalarData.Value = value;
			if (value.Length == 0)
			{
				if (scalar.Tag == "tag:yaml.org,2002:null")
				{
					scalarData.IsMultiline = false;
					scalarData.IsFlowPlainAllowed = false;
					scalarData.IsBlockPlainAllowed = true;
					scalarData.IsSingleQuotedAllowed = false;
					scalarData.IsBlockAllowed = false;
				}
				else
				{
					scalarData.IsMultiline = false;
					scalarData.IsFlowPlainAllowed = false;
					scalarData.IsBlockPlainAllowed = false;
					scalarData.IsSingleQuotedAllowed = true;
					scalarData.IsBlockAllowed = false;
				}
				return;
			}
			bool flag = false;
			bool flag2 = false;
			if (value.StartsWith("---", StringComparison.Ordinal) || value.StartsWith("...", StringComparison.Ordinal))
			{
				flag = true;
				flag2 = true;
			}
			StringLookAheadBufferPool.BufferWrapper bufferWrapper = StringLookAheadBufferPool.Rent(value);
			try
			{
				CharacterAnalyzer<StringLookAheadBuffer> characterAnalyzer = new CharacterAnalyzer<StringLookAheadBuffer>(bufferWrapper.Buffer);
				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;
			}
			finally
			{
				((IDisposable)bufferWrapper).Dispose();
			}
		}

		private bool ValueIsRepresentableInOutputEncoding(string value)
		{
			if (outputUsesUnicodeEncoding)
			{
				return true;
			}
			try
			{
				byte[] bytes = output.Encoding.GetBytes(value);
				string @string = output.Encoding.GetString(bytes, 0, bytes.Length);
				return @string.Equals(value);
			}
			catch (EncoderFallbackException)
			{
				return false;
			}
			catch (ArgumentOutOfRangeException)
			{
				return false;
			}
		}

		private static bool IsUnicode(Encoding encoding)
		{
			if (!(encoding is UTF8Encoding) && !(encoding is UnicodeEncoding))
			{
				return encoding is UTF7Encoding;
			}
			return true;
		}

		private void AnalyzeTag(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;
				foreach (TagDirective value in defaultTagDirectives)
				{
					AppendTagDirectiveTo(value, allowDuplicates: true, tagDirectives);
				}
				if (tagDirectiveCollection.Count > 0)
				{
					flag = false;
					TagDirective[] defaultTagDirectives2 = Constants.DefaultTagDirectives;
					foreach (TagDirective value2 in defaultTagDirectives2)
					{
						AppendTagDirectiveTo(value2, 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 static TagDirectiveCollection NonDefaultTagsAmong(IEnumerable<TagDirective>? tagCollection)
		{
			TagDirectiveCollection tagDirectiveCollection = new TagDirectiveCollection();
			if (tagCollection == null)
			{
				return tagDirectiveCollection;
			}
			foreach (TagDirective item2 in tagCollection)
			{
				AppendTagDirectiveTo(item2, allowDuplicates: false, tagDirectiveCollection);
			}
			TagDirective[] defaultTagDirectives = Constants.DefaultTagDirectives;
			foreach (TagDirective item in defaultTagDirectives)
			{
				tagDirectiveCollection.Remove(item);
			}
			return tagDirectiveCollection;
		}

		private static 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;
			}
			if (scalarStyle == ScalarStyle.ForcePlain)
			{
				scalarStyle = ScalarStyle.Plain;
			}
			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.");
						}
						if (useUtf16SurrogatePair)
						{
							Write('u');
							Write(num.ToString("X04", CultureInfo.InvariantCulture));
							Write('\\');
							Write('u');
							Write(((ushort)value[i + 1]).ToString("X04", CultureInfo.InvariantCulture));
						}
						else
						{
							Write('U');
							Write(char.ConvertToUtf32(c, value[i + 1]).ToString("X08", CultureInfo.InvariantCulture));
						}
						i++;
					}
					else
					{
						Write('u');
						Write(num.ToString("X04", CultureInfo.InvariantCulture));
					}
					break;
				}
				}
				flag = false;
			}
			WriteIndicator("\"", needWhitespace: false, whitespace: false, indentation: false);
			isWhitespace = false;
			isIndentation = false;
		}

		private void WriteLiteralScalar(string value)
		{
			bool flag = true;
			WriteIndicator("|", needWhitespace: true, whitespace: false, indentation: false);
			WriteBlockScalarHints(value);
			WriteBreak();
			isIndentation = true;
			isWhitespace = true;
			for (int i = 0; i < value.Length; i++)
			{
				char c = value[i];
				if (c == '\r' && i + 1 < value.Length && value[i + 1] == '\n')
				{
					continue;
				}
				if (IsBreak(c, out var breakChar))
				{
					WriteBreak(breakChar);
					isIndentation = true;
					flag = true;
					continue;
				}
				if (flag)
				{
					WriteIndent();
				}
				Write(c);
				isIndentation = false;
				flag = false;
			}
		}

		private void WriteFoldedScalar(string value)
		{
			bool flag = true;
			bool flag2 = true;
			WriteIndicator(">", needWhitespace: true, whitespace: false, indentation: false);
			WriteBlockScalarHints(value);
			WriteBreak();
			isIndentation = true;
			isWhitespace = true;
			for (int i = 0; i < value.Length; i++)
			{
				char c = value[i];
				if (IsBreak(c, out var breakChar))
				{
					if (c == '\r' && i + 1 < value.Length && value[i + 1] == '\n')
					{
						continue;
					}
					if (!flag && !flag2 && breakChar == '\n')
					{
						int j;
						char breakChar2;
						for (j = 0; i + j < value.Length && IsBreak(value[i + j], out breakChar2); j++)
						{
						}
						if (i + j < value.Length && !IsBlank(value[i + j]) && !IsBreak(value[i + j], out breakChar2))
						{
							WriteBreak();
						}
					}
					WriteBreak(breakChar);
					isIndentation = true;
					flag = true;
				}
				else
				{
					if (flag)
					{
						WriteIndent();
						flag2 = IsBlank(c);
					}
					if (!flag && c == ' ' && i + 1 < value.Length && value[i + 1] != ' ' && column > bestWidth)
					{
						WriteIndent();
					}
					else
					{
						Write(c);
					}
					isIndentation = false;
					flag = false;
				}
			}
		}

		private static bool IsSpace(char character)
		{
			return character == ' ';
		}

		private static bool IsBreak(char character, out char breakChar)
		{
			switch (character)
			{
			case '\n':
			case '\r':
			case '\u0085':
				breakChar = '\n';
				return true;
			case '\u2028':
			case '\u2029':
				breakChar = character;
				return true;
			default:
				breakChar = '\0';
				return false;
			}
		}

		private static bool IsBlank(char character)
		{
			if (character != ' ')
			{
				return character == '\t';
			}
			return true;
		}

		private static bool IsPrintable(char character)
		{
			switch (character)
			{
			default:
				if (character != '\u0085' && (character < '\u00a0' || character > '\ud7ff'))
				{
					if (character >= '\ue000')
					{
						return character <= '\ufffd';
					}
					return false;
				}
				break;
			case '\t':
			case '\n':
			case '\r':
			case ' ':
			case '!':
			case '"':
			case '#':
			case '$':
			case '%':
			case '&':
			case '\'':
			case '(':
			case ')':
			case '*':
			case '+':
			case ',':
			case '-':
			case '.':
			case '/':
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
			case ':':
			case ';':
			case '<':
			case '=':
			case '>':
			case '?':
			case '@':
			case 'A':
			case 'B':
			case 'C':
			case 'D':
			case 'E':
			case 'F':
			case 'G':
			case 'H':
			case 'I':
			case 'J':
			case 'K':
			case 'L':
			case 'M':
			case 'N':
			case 'O':
			case 'P':
			case 'Q':
			case 'R':
			case 'S':
			case 'T':
			case 'U':
			case 'V':
			case 'W':
			case 'X':
			case 'Y':
			case 'Z':
			case '[':
			case '\\':
			case ']':
			case '^':
			case '_':
			case '`':
			case 'a':
			case 'b':
			case 'c':
			case 'd':
			case 'e':
			case 'f':
			case 'g':
			case 'h':
			case 'i':
			case 'j':
			case 'k':
			case 'l':
			case 'm':
			case 'n':
			case 'o':
			case 'p':
			case 'q':
			case 'r':
			case 's':
			case 't':
			case 'u':
			case 'v':
			case 'w':
			case 'x':
			case 'y':
			case 'z':
			case '{':
			case '|':
			case '}':
			case '~':
				break;
			}
			return true;
		}

		private static bool IsHighSurrogate(char c)
		{
			if ('\ud800' <= c)
			{
				return c <= '\udbff';
			}
			return false;
		}

		private static bool IsLowSurrogate(char c)
		{
			if ('\udc00' <= c)
			{
				return c <= '\udfff';
			}
			return false;
		}

		private void EmitSequenceStart(ParsingEvent evt)
		{
			ProcessAnchor();
			ProcessTag();
			SequenceStart sequenceStart = (SequenceStart)evt;
			if (flowLevel != 0 || isCanonical || sequenceStart.Style == SequenceStyle.Flow || CheckEmptySequence())
			{
				state = EmitterState.FlowSequenceFirstItem;
			}
			else
			{
				state = EmitterState.BlockSequenceFirstItem;
			}
		}

		private void EmitMappingStart(ParsingEvent evt)
		{
			ProcessAnchor();
			ProcessTag();
			MappingStart mappingStart = (MappingStart)evt;
			if (flowLevel != 0 || isCanonical || mappingStart.Style == MappingStyle.Flow || CheckEmptyMapping())
			{
				state = EmitterState.FlowMappingFirstKey;
			}
			else
			{
				state = EmitterState.BlockMappingFirstKey;
			}
		}

		private void ProcessAnchor()
		{
			if (!anchorData.Anchor.IsEmpty && !skipAnchorName)
			{
				WriteIndicator(anchorData.IsAlias ? "*" : "&", needWhitespace: true, whitespace: false, indentation: false);
				WriteAnchor(anchorData.Anchor);
			}
		}

		private void ProcessTag()
		{
			if (tagData.Handle == null && tagData.Suffix == null)
			{
				return;
			}
			if (tagData.Handle != null)
			{
				WriteTagHandle(tagData.Handle);
				if (tagData.Suffix != null)
				{
					WriteTagContent(tagData.Suffix, needsWhitespace: false);
				}
			}
			else
			{
				WriteIndicator("!<", needWhitespace: true, whitespace: false, indentation: false);
				WriteTagContent(tagData.Suffix, needsWhitespace: false);
				WriteIndicator(">", needWhitespace: false, whitespace: false, indentation: false);
			}
		}

		private void EmitDocumentEnd(ParsingEvent evt)
		{
			if (evt is YamlDotNet.Core.Events.DocumentEnd documentEnd)
			{
				WriteIndent();
				if (!documentEnd.IsImplicit)
				{
					WriteIndicator("...", needWhitespace: true, whitespace: false, indentation: false);
					WriteIndent();
					isDocumentEndWritten = true;
				}
				state = EmitterState.DocumentStart;
				tagDirectives.Clear();
				return;
			}
			throw new YamlException("Expected DOCUMENT-END.");
		}

		private void EmitFlowSequenceItem(ParsingEvent evt, bool isFirst)
		{
			if (isFirst)
			{
				WriteIndicator("[", needWhitespace: true, whitespace: true, indentation: false);
				IncreaseIndent(isFlow: true, isIndentless: false);
				flowLevel++;
			}
			if (evt is SequenceEnd)
			{
				flowLevel--;
				indent = indents.Pop();
				if (isCanonical && !isFirst)
				{
					WriteIndicator(",", needWhitespace: false, whitespace: false, indentation: false);
					WriteIndent();
				}
				WriteIndicator("]", needWhitespace: false, whitespace: false, indentation: false);
				state = states.Pop();
			}
			else
			{
				if (!isFirst)
				{
					WriteIndicator(",", needWhitespace: false, whitespace: false, indentation: false);
				}
				if (isCanonical || column > bestWidth)
				{
					WriteIndent();
				}
				states.Push(EmitterState.FlowSequenceItem);
				EmitNode(evt, isMapping: false, isSimpleKey: false);
			}
		}

		private void EmitFlowMappingKey(ParsingEvent evt, bool isFirst)
		{
			if (isFirst)
			{
				WriteIndicator("{", needWhitespace: true, whitespace: true, indentation: false);
				IncreaseIndent(isFlow: true, isIndentless: false);
				flowLevel++;
			}
			if (evt is MappingEnd)
			{
				flowLevel--;
				indent = indents.Pop();
				if (isCanonical && !isFirst)
				{
					WriteIndicator(",", needWhitespace: false, whitespace: false, indentation: false);
					WriteIndent();
				}
				WriteIndicator("}", needWhitespace: false, whitespace: false, indentation: false);
				state = states.Pop();
				return;
			}
			if (!isFirst)
			{
				WriteIndicator(",", needWhitespace: false, whitespace: false, indentation: false);
			}
			if (isCanonical || column > bestWidth)
			{
				WriteIndent();
			}
			if (!isCanonical && CheckSimpleKey())
			{
				states.Push(EmitterState.FlowMappingSimpleValue);
				EmitNode(evt, isMapping: true, isSimpleKey: true);
			}
			else
			{
				WriteIndicator("?", needWhitespace: true, whitespace: false, indentation: false);
				states.Push(EmitterState.FlowMappingValue);
				EmitNode(evt, isMapping: true, isSimpleKey: false);
			}
		}

		private void EmitFlowMappingValue(ParsingEvent evt, bool isSimple)
		{
			if (isSimple)
			{
				WriteIndicator(":", needWhitespace: false, whitespace: false, indentation: false);
			}
			else
			{
				if (isCanonical || column > bestWidth)
				{
					WriteIndent();
				}
				WriteIndicator(":", needWhitespace: true, whitespace: false, indentation: false);
			}
			states.Push(EmitterState.FlowMappingKey);
			EmitNode(evt, isMapping: true, isSimpleKey: false);
		}

		private void EmitBlockSequenceItem(ParsingEvent evt, bool isFirst)
		{
			if (isFirst)
			{
				IncreaseIndent(isFlow: false, isMappingContext && !isIndentation);
			}
			if (evt is SequenceEnd)
			{
				indent = indents.Pop();
				state = states.Pop();
				return;
			}
			WriteIndent();
			WriteIndicator("-", needWhitespace: true, whitespace: false, indentation: true);
			states.Push(EmitterState.BlockSequenceItem);
			EmitNode(evt, isMapping: false, isSimpleKey: false);
		}

		private void EmitBlockMappingKey(ParsingEvent evt, bool isFirst)
		{
			if (isFirst)
			{
				IncreaseIndent(isFlow: false, isIndentless: false);
			}
			if (evt is MappingEnd)
			{
				indent = indents.Pop();
				state = states.Pop();
				return;
			}
			WriteIndent();
			if (CheckSimpleKey())
			{
				states.Push(EmitterState.BlockMappingSimpleValue);
				EmitNode(evt, isMapping: true, isSimpleKey: true);
				WriteIndicator(":", needWhitespace: false, whitespace: false, indentation: false);
			}
			else
			{
				WriteIndicator("?", needWhitespace: true, whitespace: false, indentation: true);
				states.Push(EmitterState.BlockMappingValue);
				EmitNode(evt, isMapping: true, isSimpleKey: false);
			}
		}

		private void EmitBlockMappingValue(ParsingEvent evt, bool isSimple)
		{
			if (!isSimple)
			{
				WriteIndent();
				WriteIndicator(":", needWhitespace: true, whitespace: false, indentation: true);
			}
			states.Push(EmitterState.BlockMappingKey);
			EmitNode(evt, isMapping: true, isSimpleKey: false);
		}

		private void IncreaseIndent(bool isFlow, bool isIndentless)
		{
			indents.Push(indent);
			if (indent < 0)
			{
				indent = (isFlow ? bestIndent : 0);
			}
			else if (!isIndentless || !forceIndentLess)
			{
				indent += bestIndent;
			}
		}

		private bool CheckEmptyDocument()
		{
			int num = 0;
			foreach (ParsingEvent @event in events)
			{
				num++;
				if (num == 2)
				{
					if (@event is YamlDotNet.Core.Events.Scalar scalar)
					{
						return string.IsNullOrEmpty(scalar.Value);
					}
					break;
				}
			}
			return false;
		}

		private bool CheckSimpleKey()
		{
			if (events.Count < 1)
			{
				return false;
			}
			int num;
			switch (events.Peek().Type)
			{
			case EventType.Alias:
				num = AnchorNameLength(anchorData.Anchor);
				break;
			case EventType.Scalar:
				if (scalarData.IsMultiline)
				{
					return false;
				}
				num = AnchorNameLength(anchorData.Anchor) + SafeStringLength(tagData.Handle) + SafeStringLength(tagData.Suffix) + SafeStringLength(scalarData.Value);
				break;
			case EventType.SequenceStart:
				if (!CheckEmptySequence())
				{
					return false;
				}
				num = AnchorNameLength(anchorData.Anchor) + SafeStringLength(tagData.Handle) + SafeStringLength(tagData.Suffix);
				break;
			case EventType.MappingStart:
				if (!CheckEmptySequence())
				{
					return false;
				}
				num = AnchorNameLength(anchorData.Anchor) + SafeStringLength(tagData.Handle) + SafeStringLength(tagData.Suffix);
				break;
			default:
				return false;
			}
			return num <= maxSimpleKeyLength;
		}

		private static int AnchorNameLength(AnchorName value)
		{
			if (!value.IsEmpty)
			{
				return value.Value.Length;
			}
			return 0;
		}

		private static int SafeStringLength(string? value)
		{
			return value?.Length ?? 0;
		}

		private bool CheckEmptySequence()
		{
			return CheckEmptyStructure<SequenceStart, SequenceEnd>();
		}

		private bool CheckEmptyMapping()
		{
			return CheckEmptyStructure<MappingStart, MappingEnd>();
		}

		private bool CheckEmptyStructure<TStart, TEnd>() where TStart : NodeEvent where TEnd : ParsingEvent
		{
			if (events.Count < 2)
			{
				return false;
			}
			using Queue<ParsingEvent>.Enumerator enumerator = events.GetEnumerator();
			return enumerator.MoveNext() && enumerator.Current is TStart && enumerator.MoveNext() && enumerator.Current is TEnd;
		}

		private void WriteBlockScalarHints(string value)
		{
			StringLookAheadBufferPool.BufferWrapper bufferWrapper = StringLookAheadBufferPool.Rent(value);
			try
			{
				CharacterAnalyzer<StringLookAheadBuffer> characterAnalyzer = new CharacterAnalyzer<StringLookAheadBuffer>(bufferWrapper.Buffer);
				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);
				}
			}
			finally
			{
				((IDisposable)bufferWrapper).Dispose();
			}
		}

		private void WriteIndicator(string indicator, bool needWhitespace, bool whitespace, bool indentation)
		{
			if (needWhitespace && !isWhitespace)
			{
				Write(' ');
			}
			Write(indicator);
			isWhitespace = whitespace;
			isIndentation &= indentation;
		}

		private void WriteIndent()
		{
			int num = Math.Max(indent, 0);
			if (!isIndentation || column > num || (column == num && !isWhitespace))
			{
				WriteBreak();
			}
			while (column < num)
			{
				Write(' ');
			}
			isWhitespace = true;
			isIndentation = true;
		}

		private void WriteAnchor(AnchorName value)
		{
			Write(value.Value);
			isWhitespace = false;
			isIndentation = false;
		}

		private void WriteTagHandle(string value)
		{
			if (!isWhitespace)
			{
				Write(' ');
			}
			Write(value);
			isWhitespace = false;
			isIndentation = false;
		}

		private void WriteTagContent(string value, bool needsWhitespace)
		{
			if (needsWhitespace && !isWhitespace)
			{
				Write(' ');
			}
			Write(UrlEncode(value));
			isWhitespace = false;
			isIndentation = false;
		}

		private static string UrlEncode(string text)
		{
			return UriReplacer.Replace(text, delegate(Match match)
			{
				StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
				try
				{
					StringBuilder builder = builderWrapper.Builder;
					byte[] bytes = Encoding.UTF8.GetBytes(match.Value);
					foreach (byte b in bytes)
					{
						builder.AppendFormat(CultureInfo.InvariantCulture, "%{0:X02}", b);
					}
					return builder.ToString();
				}
				finally
				{
					((IDisposable)builderWrapper).Dispose();
				}
			});
		}

		private void Write(char value)
		{
			output.Write(value);
			column++;
		}

		private void Write(string value)
		{
			output.Write(value);
			column += value.Length;
		}

		private void WriteBreak(char breakCharacter = '\n')
		{
			if (breakCharacter == '\n')
			{
				output.WriteLine();
			}
			else
			{
				output.Write(breakCharacter);
			}
			column = 0;
		}
	}
	internal sealed class 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 bool UseUtf16SurrogatePairs { get; }

		public EmitterSettings()
		{
		}

		public EmitterSettings(int bestIndent, int bestWidth, bool isCanonical, int maxSimpleKeyLength, bool skipAnchorName = false, bool indentSequences = false, string? newLine = null, bool useUtf16SurrogatePairs = false)
		{
			if (bestIndent < 2 || bestIndent > 9)
			{
				throw new ArgumentOutOfRangeException("bestIndent", "BestIndent must be between 2 and 9, inclusive");
			}
			if (bestWidth <= bestIndent * 2)
			{
				throw new ArgumentOutOfRangeException("bestWidth", "BestWidth must be greater than BestIndent x 2.");
			}
			if (maxSimpleKeyLength < 0)
			{
				throw new ArgumentOutOfRangeException("maxSimpleKeyLength", "MaxSimpleKeyLength must be >= 0");
			}
			BestIndent = bestIndent;
			BestWidth = bestWidth;
			IsCanonical = isCanonical;
			MaxSimpleKeyLength = maxSimpleKeyLength;
			SkipAnchorName = skipAnchorName;
			IndentSequences = indentSequences;
			NewLine = newLine ?? Environment.NewLine;
			UseUtf16SurrogatePairs = useUtf16SurrogatePairs;
		}

		public EmitterSettings WithBestIndent(int bestIndent)
		{
			return new EmitterSettings(bestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, IndentSequences, NewLine, UseUtf16SurrogatePairs);
		}

		public EmitterSettings WithBestWidth(int bestWidth)
		{
			return new EmitterSettings(BestIndent, bestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, IndentSequences, NewLine, UseUtf16SurrogatePairs);
		}

		public EmitterSettings WithMaxSimpleKeyLength(int maxSimpleKeyLength)
		{
			return new EmitterSettings(BestIndent, BestWidth, IsCanonical, maxSimpleKeyLength, SkipAnchorName, IndentSequences, NewLine, UseUtf16SurrogatePairs);
		}

		public EmitterSettings WithNewLine(string newLine)
		{
			return new EmitterSettings(BestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, IndentSequences, newLine, UseUtf16SurrogatePairs);
		}

		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, UseUtf16SurrogatePairs);
		}

		public EmitterSettings WithIndentedSequences()
		{
			return new EmitterSettings(BestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, indentSequences: true, NewLine, UseUtf16SurrogatePairs);
		}

		public EmitterSettings WithUtf16SurrogatePairs()
		{
			return new EmitterSettings(BestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, IndentSequences, NewLine, useUtf16SurrogatePairs: true);
		}
	}
	internal enum EmitterState
	{
		StreamStart,
		StreamEnd,
		FirstDocumentStart,
		DocumentStart,
		DocumentContent,
		DocumentEnd,
		FlowSequenceFirstItem,
		FlowSequenceItem,
		FlowMappingFirstKey,
		FlowMappingKey,
		FlowMappingSimpleValue,
		FlowMappingValue,
		BlockSequenceFirstItem,
		BlockSequenceItem,
		BlockMappingFirstKey,
		BlockMappingKey,
		BlockMappingSimpleValue,
		BlockMappingValue
	}
	internal sealed class ForwardAnchorNotSupportedException : YamlException
	{
		public ForwardAnchorNotSupportedException(string message)
			: base(message)
		{
		}

		public ForwardAnchorNotSupportedException(in Mark start, in Mark end, string message)
			: base(in start, in end, message)
		{
		}

		public ForwardAnchorNotSupportedException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	internal static class HashCode
	{
		public static int CombineHashCodes(int h1, int h2)
		{
			return ((h1 << 5) + h1) ^ h2;
		}

		public static int CombineHashCodes(int h1, object? o2)
		{
			return CombineHashCodes(h1, GetHashCode(o2));
		}

		private static int GetHashCode(object? obj)
		{
			return obj?.GetHashCode() ?? 0;
		}
	}
	internal interface IEmitter
	{
		void Emit(ParsingEvent @event);
	}
	internal interface ILookAheadBuffer
	{
		bool EndOfInput { get; }

		char Peek(int offset);

		void Skip(int length);
	}
	internal sealed class InsertionQueue<T> : IEnumerable<T>, IEnumerable
	{
		private const int DefaultInitialCapacity = 128;

		private T[] items;

		private int readPtr;

		private int writePtr;

		private int mask;

		private int count;

		public int Count => count;

		public int Capacity => items.Length;

		public InsertionQueue(int initialCapacity = 128)
		{
			if (initialCapacity <= 0)
			{
				throw new ArgumentOutOfRangeException("initialCapacity", "The initial capacity must be a positive number.");
			}
			if (!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();
		}
	}
	internal interface IParser
	{
		ParsingEvent? Current { get; }

		bool MoveNext();
	}
	internal interface IScanner
	{
		Mark CurrentPosition { get; }

		Token? Current { get; }

		bool MoveNext();

		bool MoveNextWithoutConsuming();

		void ConsumeCurrent();
	}
	[DebuggerStepThrough]
	internal sealed class LookAheadBuffer : ILookAheadBuffer
	{
		private readonly TextReader input;

		private readonly char[] buffer;

		private readonly int blockSize;

		private readonly int mask;

		private int firstIndex;

		private int writeOffset;

		private int count;

		private bool endOfInput;

		public bool EndOfInput
		{
			get
			{
				if (endOfInput)
				{
					return count == 0;
				}
				return false;
			}
		}

		public LookAheadBuffer(TextReader input, int capacity)
		{
			if (capacity < 1)
			{
				throw new ArgumentOutOfRangeException("capacity", "The capacity must be positive.");
			}
			if (!capacity.IsPowerOfTwo())
			{
				throw new ArgumentException("The capacity must be a power of 2.", "capacity");
			}
			this.input = input ?? throw new ArgumentNullException("input");
			blockSize = capacity;
			buffer = new char[capacity * 2];
			mask = capacity * 2 - 1;
		}

		private int GetIndexForOffset(int offset)
		{
			return (firstIndex + offset) & mask;
		}

		public char Peek(int offset)
		{
			if (offset >= count)
			{
				FillBuffer();
			}
			if (offset < count)
			{
				return buffer[(firstIndex + offset) & mask];
			}
			return '\0';
		}

		public void Cache(int length)
		{
			if (length >= count)
			{
				FillBuffer();
			}
		}

		private void FillBuffer()
		{
			if (endOfInput)
			{
				return;
			}
			int num = blockSize;
			do
			{
				int num2 = input.Read(buffer, writeOffset, num);
				if (num2 == 0)
				{
					endOfInput = true;
					return;
				}
				num -= num2;
				writeOffset += num2;
				count += num2;
			}
			while (num > 0);
			if (writeOffset == buffer.Length)
			{
				writeOffset = 0;
			}
		}

		public void Skip(int length)
		{
			if (length < 1 || length > blockSize)
			{
				throw new ArgumentOutOfRangeException("length", "The length must be between 1 and the number of characters in the buffer. Use the Peek() and / or Cache() methods to fill the buffer.");
			}
			firstIndex = GetIndexForOffset(length);
			count -= length;
		}
	}
	internal readonly struct Mark : IEquatable<Mark>, IComparable<Mark>, IComparable
	{
		public static readonly Mark Empty = new Mark(0L, 1L, 1L);

		public long Index { get; }

		public long Line { get; }

		public long Column { get; }

		public Mark(long index, long line, long column)
		{
			if (index < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException("index", "Index must be greater than or equal to zero.");
			}
			if (line < 1)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException("line", "Line must be greater than or equal to 1.");
			}
			if (column < 1)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException("column", "Column must be greater than or equal to 1.");
			}
			Index = index;
			Line = line;
			Column = column;
		}

		public override string ToString()
		{
			return $"Line: {Line}, Col: {Column}, Idx: {Index}";
		}

		public override bool Equals(object? obj)
		{
			return Equals((Mark)(obj ?? ((object)Empty)));
		}

		public bool Equals(Mark other)
		{
			if (Index == other.Index && Line == other.Line)
			{
				return Column == other.Column;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return HashCode.CombineHashCodes(Index.GetHashCode(), HashCode.CombineHashCodes(Line.GetHashCode(), Column.GetHashCode()));
		}

		public int CompareTo(object? obj)
		{
			return CompareTo((Mark)(obj ?? ((object)Empty)));
		}

		public int CompareTo(Mark other)
		{
			int num = Line.CompareTo(other.Line);
			if (num == 0)
			{
				num = Column.CompareTo(other.Column);
			}
			return num;
		}

		public static bool operator ==(Mark left, Mark right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(Mark left, Mark right)
		{
			return !(left == right);
		}

		public static bool operator <(Mark left, Mark right)
		{
			return left.CompareTo(right) < 0;
		}

		public static bool operator <=(Mark left, Mark right)
		{
			return left.CompareTo(right) <= 0;
		}

		public static bool operator >(Mark left, Mark right)
		{
			return left.CompareTo(right) > 0;
		}

		public static bool operator >=(Mark left, Mark right)
		{
			return left.CompareTo(right) >= 0;
		}
	}
	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)
		{
		}
	}
	internal sealed class MergingParser : IParser
	{
		private sealed class ParsingEventCollection : IEnumerable<LinkedListNode<ParsingEvent>>, IEnumerable
		{
			private readonly LinkedList<ParsingEvent> events;

			private readonly HashSet<LinkedListNode<ParsingEvent>> deleted;

			private readonly Dictionary<AnchorName, LinkedListNode<ParsingEvent>> references;

			public ParsingEventCollection()
			{
				events = new LinkedList<ParsingEvent>();
				deleted = new HashSet<LinkedListNode<ParsingEvent>>();
				references = new Dictionary<AnchorName, LinkedListNode<ParsingEvent>>();
			}

			public void AddAfter(LinkedListNode<ParsingEvent> node, IEnumerable<ParsingEvent> items)
			{
				foreach (ParsingEvent item in items)
				{
					node = events.AddAfter(node, item);
				}
			}

			public void Add(ParsingEvent item)
			{
				LinkedListNode<ParsingEvent> node = events.AddLast(item);
				AddReference(item, node);
			}

			public void MarkDeleted(LinkedListNode<ParsingEvent> node)
			{
				deleted.Add(node);
			}

			public bool IsDeleted(LinkedListNode<ParsingEvent> node)
			{
				return deleted.Contains(node);
			}

			public void CleanMarked()
			{
				foreach (LinkedListNode<ParsingEvent> item in deleted)
				{
					events.Remove(item);
				}
			}

			public IEnumerable<LinkedListNode<ParsingEvent>> FromAnchor(AnchorName anchor)
			{
				LinkedListNode<ParsingEvent> next = references[anchor].Next;
				return Enumerate(next);
			}

			public IEnumerator<LinkedListNode<ParsingEvent>> GetEnumerator()
			{
				return Enumerate(events.First).GetEnumerator();
			}

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

			private static IEnumerable<LinkedListNode<ParsingEvent>> Enumerate(LinkedListNode<ParsingEvent>? node)
			{
				while (node != null)
				{
					yield return node;
					node = node.Next;
				}
			}

			private void AddReference(ParsingEvent item, LinkedListNode<ParsingEvent> node)
			{
				if (item is MappingStart mappingStart)
				{
					AnchorName anchor = mappingStart.Anchor;
					if (!anchor.IsEmpty)
					{
						references[anchor] = node;
					}
				}
			}
		}

		private sealed class ParsingEventCloner : IParsingEventVisitor
		{
			private ParsingEvent? clonedEvent;

			public ParsingEvent Clone(ParsingEvent e)
			{
				e.Accept(this);
				if (clonedEvent == null)
				{
					throw new InvalidOperationException($"Could not clone event of type '{e.Type}'");
				}
				return clonedEvent;
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.AnchorAlias e)
			{
				clonedEvent = new YamlDotNet.Core.Events.AnchorAlias(e.Value, e.Start, e.End);
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.StreamStart e)
			{
				throw new NotSupportedException();
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.StreamEnd e)
			{
				throw new NotSupportedException();
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.DocumentStart e)
			{
				throw new NotSupportedException();
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.DocumentEnd e)
			{
				throw new NotSupportedException();
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.Scalar e)
			{
				clonedEvent = new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, e.Tag, e.Value, e.Style, e.IsPlainImplicit, e.IsQuotedImplicit, e.Start, e.End);
			}

			void IParsingEventVisitor.Visit(SequenceStart e)
			{
				clonedEvent = new SequenceStart(AnchorName.Empty, e.Tag, e.IsImplicit, e.Style, e.Start, e.End);
			}

			void IParsingEventVisitor.Visit(SequenceEnd e)
			{
				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;

		public ParsingEvent? Current => iterator.Current?.Value;

		public MergingParser(IParser innerParser)
		{
			events = new ParsingEventCollection();
			merged = false;
			iterator = events.GetEnumerator();
			this.innerParser = innerParser;
		}

		public bool MoveNext()
		{
			if (!merged)
			{
				Merge();
				events.CleanMarked();
				iterator = events.GetEnumerator();
				merged = true;
			}
			return iterator.MoveNext();
		}

		private void Merge()
		{
			while (innerParser.MoveNext())
			{
				events.Add(innerParser.Current);
			}
			foreach (LinkedListNode<ParsingEvent> @event in events)
			{
				if (IsMergeToken(@event))
				{
					events.MarkDeleted(@event);
					if (!HandleMerge(@event.Next))
					{
						Mark start = @event.Value.Start;
						Mark end = @event.Value.End;
						throw new SemanticErrorException(in start, in end, "Unrecognized merge key pattern");
					}
				}
			}
		}

		private bool HandleMerge(LinkedListNode<ParsingEvent>? node)
		{
			if (node == null)
			{
				return false;
			}
			if (node.Value is YamlDotNet.Core.Events.AnchorAlias anchorAlias)
			{
				return HandleAnchorAlias(node, node, anchorAlias);
			}
			if (node.Value is SequenceStart)
			{
				return HandleSequence(node);
			}
			return false;
		}

		private bool HandleMergeSequence(LinkedListNode<ParsingEvent> sequenceStart, LinkedListNode<ParsingEvent>? node)
		{
			if (node == null)
			{
				return false;
			}
			if (node.Value is YamlDotNet.Core.Events.AnchorAlias anchorAlias)
			{
				return HandleAnchorAlias(sequenceStart, node, anchorAlias);
			}
			if (node.Value is SequenceStart)
			{
				return HandleSequence(node);
			}
			return false;
		}

		private static bool IsMergeToken(LinkedListNode<ParsingEvent> node)
		{
			if (node.Value is YamlDotNet.Core.Events.Scalar scalar)
			{
				return scalar.Value == "<<";
			}
			return false;
		}

		private bool HandleAnchorAlias(LinkedListNode<ParsingEvent> node, LinkedListNode<ParsingEvent> anchorNode, YamlDotNet.Core.Events.AnchorAlias anchorAlias)
		{
			IEnumerable<ParsingEvent> mappingEvents = GetMappingEvents(anchorAlias.Value);
			events.AddAfter(node, mappingEvents);
			events.MarkDeleted(anchorNode);
			return true;
		}

		private bool HandleSequence(LinkedListNode<ParsingEvent> node)
		{
			events.MarkDeleted(node);
			LinkedListNode<ParsingEvent> linkedListNode = node;
			while (linkedListNode != null)
			{
				if (linkedListNode.Value is SequenceEnd)
				{
					events.MarkDeleted(linkedListNode);
					return true;
				}
				LinkedListNode<ParsingEvent> next = linkedListNode.Next;
				HandleMergeSequence(node, next);
				linkedListNode = next;
			}
			return true;
		}

		private IEnumerable<ParsingEvent> GetMappingEvents(AnchorName anchor)
		{
			ParsingEventCloner @object = new ParsingEventCloner();
			int nesting = 0;
			return (from e in events.FromAnchor(anchor)
				where !events.IsDeleted(e)
				select e.Value).TakeWhile((ParsingEvent e) => (nesting += e.NestingIncrease) >= 0).Select(@object.Clone);
		}
	}
	internal class Parser : IParser
	{
		private class EventQueue
		{
			private readonly Queue<ParsingEvent> highPriorityEvents = new Queue<ParsingEvent>();

			private readonly Queue<ParsingEvent> normalPriorityEvents = new Queue<ParsingEvent>();

			public int Count => highPriorityEvents.Count + normalPriorityEvents.Count;

			public void Enqueue(ParsingEvent @event)
			{
				EventType type = @event.Type;
				if (type == EventType.StreamStart || type == EventType.DocumentStart)
				{
					highPriorityEvents.Enqueue(@event);
				}
				else
				{
					normalPriorityEvents.Enqueue(@event);
				}
			}

			public ParsingEvent Dequeue()
			{
				if (highPriorityEvents.Count <= 0)
				{
					return normalPriorityEvents.Dequeue();
				}
				return highPriorityEvents.Dequeue();
			}
		}

		private readonly Stack<ParserState> states = new Stack<ParserState>();

		private readonly TagDirectiveCollection tagDirectives = new TagDirectiveCollection();

		private ParserState state;

		private readonly IScanner scanner;

		private Token? currentToken;

		private VersionDirective? version;

		private readonly EventQueue pendingEvents = new EventQueue();

		public ParsingEvent? Current { get; private set; }

		private Token? GetCurrentToken()
		{
			if (currentToken == null)
			{
				while (scanner.MoveNextWithoutConsuming())
				{
					currentToken = scanner.Current;
					if (!(currentToken is YamlDotNet.Core.Tokens.Comment comment))
					{
						break;
					}
					pendingEvents.Enqueue(new YamlDotNet.Core.Events.Comment(comment.Value, comment.IsInline, comment.Start, comment.End));
					scanner.ConsumeCurrent();
				}
			}
			return currentToken;
		}

		public Parser(TextReader input)
			: this(new Scanner(input))
		{
		}

		public Parser(IScanner scanner)
		{
			this.scanner = scanner;
		}

		public bool MoveNext()
		{
			if (state == ParserState.StreamEnd)
			{
				Current = null;
				return false;
			}
			if (pendingEvents.Count == 0)
			{
				pendingEvents.Enqueue(StateMachine());
			}
			Current = pendingEvents.Dequeue();
			return true;
		}

		private ParsingEvent StateMachine()
		{
			return state switch
			{
				ParserState.StreamStart => ParseStreamStart(), 
				ParserState.ImplicitDocumentStart => ParseDocumentStart(isImplicit: true), 
				ParserState.DocumentStart => ParseDocumentStart(isImplicit: false), 
				ParserState.DocumentContent => ParseDocumentContent(), 
				ParserState.DocumentEnd => ParseDocumentEnd(), 
				ParserState.BlockNode => ParseNode(isBlock: true, isIndentlessSequence: false), 
				ParserState.BlockNodeOrIndentlessSequence => ParseNode(isBlock: true, isIndentlessSequence: true), 
				ParserState.FlowNode => ParseNode(isBlock: false, isIndentlessSequence: false), 
				ParserState.BlockSequenceFirstEntry => ParseBlockSequenceEntry(isFirst: true), 
				ParserState.BlockSequenceEntry => ParseBlockSequenceEntry(isFirst: false), 
				ParserState.IndentlessSequenceEntry => ParseIndentlessSequenceEntry(), 
				ParserState.BlockMappingFirstKey => ParseBlockMappingKey(isFirst: true), 
				ParserState.BlockMappingKey => ParseBlockMappingKey(isFirst: false), 
				ParserState.BlockMappingValue => ParseBlockMappingValue(), 
				ParserState.FlowSequenceFirstEntry => ParseFlowSequenceEntry(isFirst: true), 
				ParserState.FlowSequenceEntry => ParseFlowSequenceEntry(isFirst: false), 
				ParserState.FlowSequenceEntryMappingKey => ParseFlowSequenceEntryMappingKey(), 
				ParserState.FlowSequenceEntryMappingValue => ParseFlowSequenceEntryMappingValue(), 
				ParserState.FlowSequenceEntryMappingEnd => ParseFlowSequenceEntryMappingEnd(), 
				ParserState.FlowMappingFirstKey => ParseFlowMappingKey(isFirst: true), 
				ParserState.FlowMappingKey => ParseFlowMappingKey(isFirst: false), 
				ParserState.FlowMappingValue => ParseFlowMappingValue(isEmpty: false), 
				ParserState.FlowMappingEmptyValue => ParseFlowMappingValue(isEmpty: true), 
				_ => throw new InvalidOperationException(), 
			};
		}

		private void Skip()
		{
			if (currentToken != null)
			{
				currentToken = null;
				scanner.ConsumeCurrent();
			}
		}

		private YamlDotNet.Core.Events.StreamStart 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;
		}

		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 YamlDotNet.Core.Events.Scalar 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();
				ParsingEvent 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();
				ParsingEvent 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.Current is FlowMappingEnd) && 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 YamlDotNet.Core.Events.DocumentEnd 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;
				ParsingEvent 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;
				ParsingEvent 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;
			ParsingEvent result;
			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;
					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;
			result = new SequenceEnd(in start, in end);
			Skip();
			return result;
		}

		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 MappingEnd 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);
		}
	}
	internal static class ParserExtensions
	{
		public static T Consume<T>(this IParser parser) where T : ParsingEvent
		{
			T result = parser.Require<T>();
			parser.MoveNext();
			return result;
		}

		public static bool TryConsume<T>(this IParser parser, [MaybeNullWhen(false)] out T @event) where T : ParsingEvent
		{
			if (parser.Accept<T>(out @event))
			{
				parser.MoveNext();
				return true;
			}
			return false;
		}

		public static T Require<T>(this IParser parser) where T : ParsingEvent
		{
			if (!parser.Accept<T>(out var @event))
			{
				ParsingEvent current = parser.Current;
				if (current == null)
				{
					throw new YamlException("Expected '" + typeof(T).Name + "', got nothing.");
				}
				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<T>(this IParser parser, [MaybeNullWhen(false)] out T @event) where T : ParsingEvent
		{
			if (parser.Current == null && !parser.MoveNext())
			{
				throw new EndOfStreamException();
			}
			if (parser.Current is T val)
			{
				@event = val;
				return true;
			}
			@event = null;
			return false;
		}

		public static void SkipThisAndNestedEvents(this IParser parser)
		{
			int num = 0;
			do
			{
				ParsingEvent parsingEvent = parser.Consume<ParsingEvent>();
				num += parsingEvent.NestingIncrease;
			}
			while (num > 0);
		}

		[Obsolete("Please use Consume<T>() instead")]
		public static T Expect<T>(this IParser parser) where T : ParsingEvent
		{
			return parser.Consume<T>();
		}

		[Obsolete("Please use TryConsume<T>(out var evt) instead")]
		[return: MaybeNull]
		public static T? Allow<T>(this IParser parser) where T : ParsingEvent
		{
			if (!parser.TryConsume<T>(out var @event))
			{
				return null;
			}
			return @event;
		}

		[Obsolete("Please use Accept<T>(out var evt) instead")]
		[return: MaybeNull]
		public static T? Peek<T>(this IParser parser) where T : ParsingEvent
		{
			if (!parser.Accept<T>(out var @event))
			{
				return null;
			}
			return @event;
		}

		[Obsolete("Please use TryConsume<T>(out var evt) or Accept<T>(out var evt) instead")]
		public static bool Accept<T>(this IParser parser) where T : ParsingEvent
		{
			T @event;
			return parser.Accept<T>(out @event);
		}

		public static bool TryFindMappingEntry(this IParser parser, Func<YamlDotNet.Core.Events.Scalar, bool> selector, [MaybeNullWhen(false)] out YamlDotNet.Core.Events.Scalar? key, [MaybeNullWhen(false)] 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 flag = selector(scalar);
					parser.MoveNext();
					if (flag)
					{
						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,
		ForcePlain
	}
	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<long> indents = new Stack<long>();

		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 bool flowCollectionFetched;

		private bool startFlowCollectionFetched;

		private long indent = -1L;

		private bool flowScalarFetched;

		private bool simpleKeyAllowed;

		private int flowLevel;

		private int tokensParsed;

		private bool tokenAvailable;

		private Token? previous;

		private Anchor? previousAnchor;

		private YamlDotNet.Core.Tokens.Scalar? lastScalar;

		private readonly int maxKeySize;

		private static readonly byte[] EmptyBytes = Array.Empty<byte>();

		public bool SkipComments { get; private set; }

		public Token? Current { get; private set; }

		public Mark CurrentPosition => cursor.Mark();

		private bool IsDocumentStart()
		{
			if (!analyzer.EndOfInput && cursor.LineOffset == 0L && analyzer.Check('-') && analyzer.Check('-', 1) && analyzer.Check('-', 2))
			{
				return analyzer.IsWhiteBreakOrZero(3);
			}
			return false;
		}

		private bool IsDocumentEnd()
		{
			if (!analyzer.EndOfInput && cursor.LineOffset == 0L && analyzer.Check('.') && analyzer.Check('.', 1) && analyzer.Check('.', 2))
			{
				return analyzer.IsWhiteBreakOrZero(3);
			}
			return false;
		}

		private bool IsDocumentIndicator()
		{
			if (!IsDocumentStart())
			{
				return IsDocumentEnd();
			}
			return true;
		}

		public Scanner(TextReader input, bool skipComments = true)
			: this(input, skipComments, 1024)
		{
		}

		public Scanner(TextReader input, bool skipComments, int maxKeySize)
		{
			analyzer = new CharacterAnalyzer<LookAheadBuffer>(new LookAheadBuffer(input, 1024));
			cursor = new Cursor();
			SkipComments = skipComments;
			this.maxKeySize = maxKeySize;
		}

		public bool MoveNext()
		{
			if (Current != null)
			{
				ConsumeCurrent();
			}
			return MoveNextWithoutConsuming();
		}

		public bool MoveNextWithoutConsuming()
		{
			if (!tokenAvailable && !streamEndProduced)
			{
				FetchMoreTokens();
			}
			if (tokens.Count > 0)
			{
				Current = tokens.Dequeue();
				tokenAvailable = false;
				return true;
			}
			Current = null;
			return false;
		}

		public void ConsumeCurrent()
		{
			tokensParsed++;
			tokenAvailable = false;
			previous = Current;
			Current = null;
		}

		private char ReadCurrentCharacter()
		{
			char result = analyzer.Peek(0);
			Skip();
			return result;
		}

		private char ReadLine()
		{
			if (analyzer.Check("\r\n\u0085"))
			{
				SkipLine();
				return '\n';
			}
			char result = analyzer.Peek(0);
			SkipLine();
			return result;
		}

		private void FetchMoreTokens()
		{
			while (true)
			{
				bool flag = false;
				if (tokens.Count == 0)
				{
					flag = true;
				}
				else
				{
					foreach (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 + maxKeySize < 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 == 0L && analyzer.Check('%'))
			{
				lastScalar = null;
				FetchDirective();
				return;
			}
			if (IsDocumentStart())
			{
				lastScalar = null;
				FetchDocumentIndicator(isStartToken: true);
				return;
			}
			if (IsDocumentEnd())
			{
				lastScalar = null;
				FetchDocumentIndicator(isStartToken: false);
				return;
			}
			if (analyzer.Check('['))
			{
				lastScalar = null;
				FetchFlowCollectionStart(isSequenceToken: true);
				return;
			}
			if (analyzer.Check('{'))
			{
				lastScalar = null;
				FetchFlowCollectionStart(isSequenceToken: false);
				return;
			}
			if (analyzer.Check(']'))
			{
				lastScalar = null;
				FetchFlowCollectionEnd(isSequenceToken: true);
				return;
			}
			if (analyzer.Check('}'))
			{
				lastScalar = null;
				FetchFlowCollectionEnd(isSequenceToken: false);
				return;
			}
			if (analyzer.Check(','))
			{
				lastScalar = null;
				FetchFlowEntry();
				return;
			}
			if (analyzer.Check('-'))
			{
				if (analyzer.IsWhiteBreakOrZero(1))
				{
					FetchBlockEntry();
					return;
				}
				if (flowLevel > 0 && analyzer.Check(",[]{}", 1))
				{
					tokens.Enqueue(new Error("Invalid key indicator format.", cursor.Mark(), cursor.Mark()));
				}
			}
			if (analyzer.Check('?') && (flowLevel > 0 || analyzer.IsWhiteBreakOrZero(1)) && analyzer.IsWhiteBreakOrZero(1))
			{
				FetchKey();
			}
			else if (analyzer.Check(':') && (flowLevel > 0 || analyzer.IsWhiteBreakOrZero(1)) && (!simpleKeyAllowed || flowLevel <= 0) && (!flowScalarFetched || !analyzer.Check(':', 1)) && (analyzer.IsWhiteBreakOrZero(1) || analyzer.Check(',', 1) || flowScalarFetched || flowCollectionFetched || startFlowCollectionFetched))
			{
				if (lastScalar != null)
				{
					lastScalar.IsKey = true;
					lastScalar = null;
				}
				FetchValue();
			}
			else if (analyzer.Check('*'))
			{
				FetchAnchor(isAlias: true);
			}
			else if (analyzer.Check('&'))
			{
				FetchAnchor(isAlias: false);
			}
			else if (analyzer.Check('!'))
			{
				FetchTag();
			}
			else if (analyzer.Check('|') && flowLevel == 0)
			{
				FetchBlockScalar(isLiteral: true);
			}
			else if (analyzer.Check('>') && flowLevel == 0)
			{
				FetchBlockScalar(isLiteral: false);
			}
			else if (analyzer.Check('\''))
			{
				FetchQuotedScalar(isSingleQuoted: true);
			}
			else if (analyzer.Check('"'))
			{
				FetchQuotedScalar(isSingleQuoted: false);
			}
			else if ((!analyzer.IsWhiteBreakOrZero() && !analyzer.Check("-?:,[]{}#&*!|>'\"%@`")) || (analyzer.Check('-') && !analyzer.IsWhite(1)) || (analyzer.Check("?:") && !analyzer.IsWhiteBreakOrZero(1)) || (simpleKeyAllowed && flowLevel > 0))
			{
				if (plainScalarFollowedByComment)
				{
					Mark mark = cursor.Mark();
					tokens.Enqueue(new Error("While scanning plain scalar, found a comment between adjacent scalars.", mark, mark));
				}
				if ((flowScalarFetched || (flowCollectionFetched && !startFlowCollectionFetched)) && analyzer.Check(':'))
				{
					Skip();
				}
				flowScalarFetched = false;
				flowCollectionFetched = false;
				startFlowCollectionFetched = false;
				plainScalarFollowedByComment = false;
				FetchPlainScalar();
			}
			else
			{
				if (simpleKeyAllowed && indent >= cursor.LineOffset && analyzer.IsTab())
				{
					throw new SyntaxErrorException("While scanning a mapping, found invalid tab as indentation.");
				}
				if (!analyzer.IsWhiteBreakOrZero())
				{
					Mark start = cursor.Mark();
					Skip();
					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(long 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(-1L);
			RemoveSimpleKey();
			simpleKeyAllowed = false;
			streamEndProduced = true;
			Mark start = cursor.Mark();
			tokens.Enqueue(new YamlDotNet.Core.Tokens.StreamEnd(in start, in start));
		}

		private void FetchDirective()
		{
			UnrollIndent(-1L);
			RemoveSimpleKey();
			simpleKeyAllowed = false;
			Token token = ScanDirective();
			if (token != null)
			{
				tokens.Enqueue(token);
			}
		}

		private Token? ScanDirective()
		{
			Mark start = cursor.Mark();
			Skip();
			string text = ScanDirectiveName(in start);
			Token result;
			if (!(text == "YAML"))
			{
				if (!(text == "TAG"))
				{
					while (!analyzer.EndOfInput && !analyzer.Check('#') && !analyzer.IsBreak())
					{
						Skip();
					}
					return null;
				}
				result = ScanTagDirectiveValue(in start);
			}
			else
			{
				if (!(previous is 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(-1L);
			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 item = ((!isSequenceToken) ? ((Token)new FlowMappingStart(in start, in start)) : ((Token)new FlowSequenceStart(in start, in start)));
			tokens.Enqueue(item);
			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 == 0L && simpleKey.LineOffset == 0L)
					{
						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(long 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 Tag 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 YamlDotNet.Core.Tokens.Scalar ScanBlockScalar(bool isLiteral)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				StringBuilderPool.BuilderWrapper builderWrapper2 = StringBuilderPool.Rent();
				try
				{
					StringBuilder builder2 = builderWrapper2.Builder;
					StringBuilderPool.BuilderWrapper builderWrapper3 = StringBuilderPool.Rent();
					try
					{
						StringBuilder builder3 = builderWrapper3.Builder;
						int num = 0;
						int num2 = 0;
						long currentIndent = 0L;
						bool flag = false;
						bool? isFirstLine = null;
						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.GetValueOrDefault())
							{
								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((object?)builder2);
								builder2.Length = 0;
							}
							builder.Append((object?)builder3);
							builder3.Length = 0;
							flag = analyzer.IsWhite();
							while (!analyzer.IsBreakOrZero())
							{
								builder.Append(ReadCurrentCharacter());
							}
							char c = ReadLine();
							if (c != 0)
							{
								builder2.Append(c);
							}
							currentIndent = ScanBlockScalarBreaks(currentIndent, builder3, isLiteral, ref end2, ref isFirstLine);
						}
						if (num != -1)
						{
							builder.Append((object?)builder2);
						}
						if (num == 1)
						{
							builder.Append((object?)builder3);
						}
						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 long ScanBlockScalarBreaks(long currentIndent, StringBuilder breaks, bool isLiteral, ref Mark end, ref bool? isFirstLine)
		{
			long num = 0L;
			long num2 = -1L;
			end = cursor.Mark();
			while (true)
			{
				if ((currentIndent == 0L || cursor.LineOffset < currentIndent) && analyzer.IsSpace())
				{
					Skip();
					continue;
				}
				if (cursor.LineOffset > num)
				{
					num = cursor.LineOffset;
				}
				if (!analyzer.IsBreak())
				{
					break;
				}
				if (isFirstLine.GetValueOrDefault())
				{
					isFirstLine = false;
					num2 = cursor.LineOffset;
				}
				breaks.Append(ReadLine());
				end = cursor.Mark();
			}
			if (isLiteral && isFirstLine.GetValueOrDefault())
			{
				long num3 = cursor.LineOffset;
				int num4 = 0;
				while (!analyzer.IsBreak(num4) && analyzer.IsSpace(num4))
				{
					num4++;
					num3++;
				}
				if (analyzer.IsBreak(num4) && num3 > cursor.LineOffset)
				{
					isFirstLine = false;
					num2 = num3;
				}
			}
			if (isLiteral && num2 > 1 && currentIndent < num2 - 1)
			{
				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 == 0L && (cursor.LineOffset > 0 || indent > -1))
			{
				currentIndent = Math.Max(num, Math.Max(indent + 1, 1L));
			}
			return currentIndent;
		}

		private void FetchQuotedScalar(bool isSingleQuoted)
		{
			SaveSimpleKey();
			simpleKeyAllowed = false;
			flowScalarFetched = flowLevel > 0;
			YamlDotNet.Core.Tokens.Scalar item = ScanFlowScalar(isSingleQuoted);
			tokens.Enqueue(item);
			lastScalar = item;
			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 YamlDotNet.Core.Tokens.Scalar 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)
										{
											for (int j = 0; j < num; j++)
											{
												Skip();
											}
											if (analyzer.Peek(0) != '\\' || (analyzer.Peek(1) != 'u' && analyzer.Peek(1) != 'U'))
											{
												Mark end = cursor.Mark();
												throw new SyntaxErrorException(in start, in end, "While scanning a quoted scalar, found invalid Unicode surrogates.");
											}
											Skip();
											num = ((analyzer.Peek(0) != 'u') ? 8 : 4);
											Skip();
											int num3 = 0;
											for (int k = 0; k < num; k++)
											{
												if (!analyzer.IsHex(0))
												{
													Mark end = cursor.Mark();
													throw new SyntaxErrorException(in start, in end, "While scanning a quoted scalar, did not find expected hexadecimal number.");
												}
												num3 = (num3 << 4) + analyzer.AsHex(k);
											}
											for (int l = 0; l < num; l++)
											{
												Skip();
											}
											num2 = char.ConvertToUtf32((char)num2, (char)num3);
										}
										else
										{
											if (num2 > 1114111)
											{
												Mark end = cursor.Mark();
												throw new SyntaxErrorException(in start, in end, "While scanning a quoted scalar, found invalid Unicode character escape code.");
											}
											for (int m = 0; m < num; m++)
											{
												Skip();
											}
										}
										builder.Append(char.ConvertFromUtf32(num2));
									}
									else
									{
										builder.Append(ReadCurrentCharacter());
									}
								}
								if (analyzer.Check(isSingleQuoted ? '\'' : '"'))
								{
									break;
								}
								while (analyzer.IsWhite() || analyzer.IsBreak())
								{
									if (analyzer.IsWhite())
									{
										if (!flag)
										{
											builder2.Append(ReadCurrentCharacter());
										}
										else
										{
											Skip();
										}
									}
									else if (!flag)
									{
										builder2.Length = 0;
										builder3.Append(ReadLine());
										flag = true;
									}
									else
									{
										builder4.Append(ReadLine());
									}
								}
								if (flag)
								{
									if (StartsWith(builder3, '\n'))
									{
										if (builder4.Length == 0)
										{
											builder.Append(' ');
										}
										else
										{
											builder.Append((object?)builder4);
										}
									}
									else
									{
										builder.Append((object?)builder3);
										builder.Append((object?)builder4);
									}
									builder3.Length = 0;
									builder4.Length = 0;
								}
								else
								{
									builder.Append((object?)builder2);
									builder2.Length = 0;
								}
							}
							Skip();
							return new YamlDotNet.Core.Tokens.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;
							long 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 InvalidOperationException();
									}
									builder.Append(ReadCurrentCharacter());
									end = cursor.Mark();
								}
								if (!analyzer.IsWhite() && !analyzer.IsBreak())
								{
									break;
								}
								while (analyzer.IsWhite() || analyzer.IsBreak())
								{
									if (analyzer.IsWhite())
									{
										if (flag && cursor.LineOffset < num && analyzer.IsTab())
										{
											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 VersionDirective 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 TagDirective 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(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 (Polyfills.EndsWith(text, ','))
				{
					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);
			}
		}
	}
	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)
		{
		}
	}
	internal sealed class SimpleKey
	{
		private readonly Cursor cursor;

		public bool IsPossible { get; private set; }

		public bool IsRequired { get; }

		public int TokenNumber { get; }

		public long Index => cursor.Index;

		public long Line => cursor.Line;

		public long LineOffset => cursor.LineOffset;

		public 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, IResettable
	{
		public string Value { get; set; } = string.Empty;


		public int Position { get; private set; }

		public int Length => Value.Length;

		public bool EndOfInput => IsOutside(Position);

		public char Peek(int offset)
		{
			int index = Position + offset;
			if (!IsOutside(index))
			{
				return Value[index];
			}
			return '\0';
		}

		private bool IsOutside(int index)
		{
			return index >= Value.Length;
		}

		public void Skip(int length)
		{
			if (length < 0)
			{
				throw new ArgumentOutOfRangeException("length", "The length must be positive.");
			}
			Position += length;
		}

		public bool TryReset()
		{
			Position = 0;
			Value = string.Empty;
			return true;
		}
	}
	internal sealed class 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)
		{
		}
	}
	internal sealed class TagDirectiveCollection : KeyedCollection<string, TagDirective>
	{
		public TagDirectiveCollection()
		{
		}

		public TagDirectiveCollection(IEnumerable<TagDirective> tagDirectives)
		{
			foreach (TagDirective tagDirective in tagDirectives)
			{
				Add(tagDirective);
			}
		}

		protected override string GetKeyForItem(TagDirective item)
		{
			return item.Handle;
		}

		public new bool Contains(TagDirective directive)
		{
			return Contains(GetKeyForItem(directive));
		}
	}
	internal readonly struct TagName : IEquatable<TagName>
	{
		public static readonly TagName Empty;

		private readonly string? value;

		public string Value => value ?? throw new InvalidOperationException("Cannot read the Value of a non-specific tag");

		public bool IsEmpty => value == null;

		public bool IsNonSpecific
		{
			get
			{
				if (!IsEmpty)
				{
					if (!(value == "!"))
					{
						return value == "?";
					}
					return true;
				}
				return false;
			}
		}

		public bool IsLocal
		{
			get
			{
				if (!IsEmpty)
				{
					return Value[0] == '!';
				}
				return false;
			}
		}

		public bool IsGlobal
		{
			get
			{
				if (!IsEmpty)
				{
					return !IsLocal;
				}
				return false;
			}
		}

		public TagName(string value)
		{
			this.value = value ?? throw new ArgumentNullException("value");
			if (value.Length == 0)
			{
				throw new ArgumentException("Tag value must not be empty.", "value");
			}
			if (IsGlobal && !Uri.IsWellFormedUriString(value, UriKind.RelativeOrAbsolute))
			{
				throw new ArgumentException("Global tags must be valid URIs.", "value");
			}
		}

		public override string ToString()
		{
			return value ?? "?";
		}

		public bool Equals(TagName other)
		{
			return object.Equals(value, other.value);
		}

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

		public override int GetHashCode()
		{
			return value?.GetHashCode() ?? 0;
		}

		public static bool operator ==(TagName left, TagName right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(TagName left, TagName right)
		{
			return !(left == right);
		}

		public static bool operator ==(TagName left, string right)
		{
			return object.Equals(left.value, right);
		}

		public static bool operator !=(TagName left, string right)
		{
			return !(left == right);
		}

		public static implicit operator TagName(string? value)
		{
			if (value != null)
			{
				return new TagName(value);
			}
			return Empty;
		}
	}
	internal sealed class Version
	{
		public int Major { get; }

		public int Minor { get; }

		public Version(int major, int minor)
		{
			if (major < 0)
			{
				throw new ArgumentOutOfRangeException("major", $"{major} should be >= 0");
			}
			Major = major;
			if (minor < 0)
			{
				throw new ArgumentOutOfRangeException("minor", $"{minor} should be >= 0");
			}
			Minor = minor;
		}

		public override bool Equals(object? obj)
		{
			if (obj is Version version && Major == version.Major)
			{
				return Minor == version.Minor;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return HashCode.CombineHashCodes(Major.GetHashCode(), Minor.GetHashCode());
		}
	}
	internal class YamlException : Exception
	{
		public Mark Start { get; }

		public Mark End { get; }

		public YamlException(string message)
			: this(in Mark.Empty, in Mark.Empty, message)
		{
		}

		public YamlException(in Mark start, in Mark end, string message)
			: this(in start, in end, message, null)
		{
		}

		public YamlException(in Mark start, in Mark end, string message, Exception? innerException)
			: base(message, innerException)
		{
			Start = start;
			End = end;
		}

		public YamlException(string message, Exception inner)
			: this(in Mark.Empty, in Mark.Empty, message, inner)
		{
		}

		public override string ToString()
		{
			return $"({Start}) - ({End}): {Message}";
		}
	}
}
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)
		{
		}
	}
	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)
		{
		}
	}
	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)
		{
		}
	}
	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)
		{
		}
	}
	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");
		}
	}
	internal class TagDirective : Token
	{
		private static readonly Regex TagHandlePattern = new Regex("^!([0-9A-Za-z_\\-]*!)?$", RegexOptions.Compiled);

		public string Handle { get; }

		public string Prefix { get; }

		public TagDirective(string handle, string prefix)
			: this(handle, prefix, Mark.Empty, Mark.Empty)
		{
		}

		public TagDirective(string handle, string prefix, Mark start, Mark end)
			: base(in start, in end)
		{
			if (string.IsNullOrEmpty(handle))
			{
				throw new ArgumentNullException("handle", "Tag handle must not be empty.");
			}
			if (!TagHandlePattern.IsMatch(handle))
			{
				throw new ArgumentException("Tag handle must start and end with '!' and contain alphanumerical characters only.", "handle");
			}
			Handle = handle;
			if (string.IsNullOrEmpty(prefix))
			{
				throw new ArgumentNullException("prefix", "Tag prefix must not be empty.");
			}
			Prefix = prefix;
		}

		public override bool Equals(object? obj)
		{
			if (obj is TagDirective tagDirective && Handle.Equals(tagDirective.Handle))
			{
				return Prefix.Equals(tagDirective.Prefix);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return Handle.GetHashCode() ^ Prefix.GetHashCode();
		}

		public override string ToString()
		{
			return Handle + " => " + Prefix;
		}
	}
	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)
		{
		}
	}
	internal sealed class VersionDirective : Token
	{
		public Version Version { get; }

		public VersionDirective(Version version)
			: this(version, Mark.Empty, Mark.Empty)
		{
		}

		public VersionDirective(Version version, Mark start, Mark end)
			: base(in start, in end)
		{
			Version = version;
		}

		public override bool Equals(object? obj)
		{
			if (obj is VersionDirective versionDirective)
			{
				return Version.Equals(versionDirective.Version);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return Version.GetHashCode();
		}
	}
}
namespace YamlDotNet.Core.ObjectPool
{
	internal class DefaultObjectPool<T> : ObjectPool<T> where T : class
	{
		private readonly Func<T> createFunc;

		private readonly Func<T, bool> returnFunc;

		private readonly int maxCapacity;

		private int numItems;

		private protected readonly ConcurrentQueue<T> items = new ConcurrentQueue<T>();

		private protected T? fastItem;

		public DefaultObjectPool(IPooledObjectPolicy<T> policy)
			: this(policy, Environment.ProcessorCount * 2)
		{
		}

		public DefaultObjectPool(IPooledObjectPolicy<T> policy, int maximumRetained)
		{
			createFunc = policy.Create;
			returnFunc = policy.Return;
			maxCapacity = maximumRetained - 1;
		}

		public override T Get()
		{
			T result = fastItem;
			if (result == null || Interlocked.CompareExchange(ref fastItem, null, result) != result)
			{
				if (items.TryDequeue(out result))
				{
					Interlocked.Decrement(ref numItems);
					return result;
				}
				return createFunc();
			}
			return result;
		}

		public override void Return(T obj)
		{
			ReturnCore(obj);
		}

		private protected bool ReturnCore(T obj)
		{
			if (!returnFunc(obj))
			{
				return false;
			}
			if (fastItem != null || Interlocked.CompareExchange(ref fastItem, obj, null) != null)
			{
				if (Interlocked.Increment(ref numItems) <= maxCapacity)
				{
					items.Enqueue(obj);
					return true;
				}
				Interlocked.Decrement(ref numItems);
				return false;
			}
			return true;
		}
	}
	internal class DefaultPooledObjectPolicy<T> : IPooledObjectPolicy<T> where T : class, new()
	{
		public T Create()
		{
			return new T();
		}

		public bool Return(T obj)
		{
			if (obj is IResettable resettable)
			{
				return resettable.TryReset();
			}
			return true;
		}
	}
	internal interface IPooledObjectPolicy<T> where T : notnull
	{
		T Create();

		bool Return(T obj);
	}
	internal interface IResettable
	{
		bool TryReset();
	}
	internal abstract class ObjectPool<T> where T : class
	{
		public abstract T Get();

		public abstract void Return(T obj);
	}
	internal static class ObjectPool
	{
		public static ObjectPool<T> Create<T>(IPooledObjectPolicy<T>? policy = null) where T : class, new()
		{
			return new DefaultObjectPool<T>(policy ?? new DefaultPooledObjectPolicy<T>());
		}

		public static ObjectPool<T> Create<T>(int maximumRetained, IPooledObjectPolicy<T>? policy = null) where T : class, new()
		{
			return new DefaultObjectPool<T>(policy ?? new DefaultPooledObjectPolicy<T>(), maximumRetained);
		}
	}
	[DebuggerStepThrough]
	internal static class StringBuilderPool
	{
		internal readonly struct BuilderWrapper : IDisposable
		{
			public readonly StringBuilder Builder;

			private readonly ObjectPool<StringBuilder> pool;

			public BuilderWrapper(StringBuilder builder, ObjectPool<StringBuilder> pool)
			{
				Builder = builder;
				this.pool = pool;
			}

			public override string ToString()
			{
				return Builder.ToString();
			}

			public void Dispose()
			{
				pool.Return(Builder);
			}
		}

		private static readonly ObjectPool<StringBuilder> Pool = ObjectPool.Create(new StringBuilderPooledObjectPolicy
		{
			InitialCapacity = 16,
			MaximumRetainedCapacity = 1024
		});

		public static BuilderWrapper Rent()
		{
			StringBuilder builder = Pool.Get();
			return new BuilderWrapper(builder, Pool);
		}
	}
	internal class StringBuilderPooledObjectPolicy : IPooledObjectPolicy<StringBuilder>
	{
		public int InitialCapacity { get; set; } = 100;


		public int MaximumRetainedCapacity { get; set; } = 4096;


		public StringBuilder Create()
		{
			return new StringBuilder(InitialCapacity);
		}

		public bool Return(StringBuilder obj)
		{
			if (obj.Capacity > MaximumRetainedCapacity)
			{
				return false;
			}
			obj.Clear();
			return true;
		}
	}
	internal static class StringLookAheadBufferPool
	{
		internal readonly struct BufferWrapper : IDisposable
		{
			public readonly StringLookAheadBuffer Buffer;

			private readonly ObjectPool<StringLookAheadBuffer> pool;

			public BufferWrapper(StringLookAheadBuffer buffer, ObjectPool<StringLookAheadBuffer> pool)
			{
				Buffer = buffer;
				this.pool = pool;
			}

			public override string ToString()
			{
				return Buffer.ToString();
			}

			public void Dispose()
			{
				pool.Return(Buffer);
			}
		}

		private static readonly ObjectPool<StringLookAheadBuffer> Pool = ObjectPool.Create(new DefaultPooledObjectPolicy<StringLookAheadBuffer>());

		public static BufferWrapper Rent(string value)
		{
			StringLookAheadBuffer stringLookAheadBuffer = Pool.Get();
			stringLookAheadBuffer.Value = value;
			return new BufferWrapper(stringLookAheadBuffer, Pool);
		}
	}
}
namespace YamlDotNet.Core.Events
{
	internal sealed class AnchorAlias : ParsingEvent
	{
		internal override EventType Type => EventType.Alias;

		public AnchorName Value { get; }

		public AnchorAlias(AnchorName value, Mark start, Mark end)
			: base(in start, in end)
		{
			if (value.IsEmpty)
			{
				throw new YamlException(in start, in end, "Anchor value must not be empty.");
			}
			Value = value;
		}

		public AnchorAlias(AnchorName value)
			: this(value, Mark.Empty, Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Alias [value = {Value}]";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	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 + "]";
		}
	}
	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);
		}
	}
	internal sealed class DocumentStart : ParsingEvent
	{
		public override int NestingIncrease => 1;

		internal override EventType Type => EventType.DocumentStart;

		public TagDirectiveCollection? Tags { get; }

		public VersionDirective? Version { get; }

		public bool IsImplicit { get; }

		public DocumentStart(VersionDirective? version, TagDirectiveCollection? tags, bool isImplicit, Mark start, Mark end)
			: base(in start, in end)
		{
			Version = version;
			Tags = tags;
			IsImplicit = isImplicit;
		}

		public DocumentStart(VersionDirective? version, TagDirectiveCollection? tags, bool isImplicit)
			: this(version, tags, isImplicit, Mark.Empty, Mark.Empty)
		{
		}

		public DocumentStart(in Mark start, in Mark end)
			: this(null, null, isImplicit: true, start, end)
		{
		}

		public DocumentStart()
			: this(null, null, isImplicit: true, Mark.Empty, Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Document start [isImplicit = {IsImplicit}]";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal enum EventType
	{
		None,
		StreamStart,
		StreamEnd,
		DocumentStart,
		DocumentEnd,
		Alias,
		Scalar,
		SequenceStart,
		SequenceEnd,
		MappingStart,
		MappingEnd,
		Comment
	}
	internal interface IParsingEventVisitor
	{
		void Visit(AnchorAlias e);

		void Visit(StreamStart e);

		void Visit(StreamEnd e);

		void Visit(DocumentStart e);

		void Visit(DocumentEnd e);

		void Visit(Scalar e);

		void Visit(SequenceStart e);

		void Visit(SequenceEnd e);

		void Visit(MappingStart e);

		void Visit(MappingEnd e);

		void Visit(Comment e);
	}
	internal class MappingEnd : ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override EventType Type => EventType.MappingEnd;

		public MappingEnd(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);
		}
	}
	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; }

		public abstract void Accept(IParsingEventVisitor visitor);

		internal ParsingEvent(in Mark start, in Mark end)
		{
			Start = start;
			End = end;
		}
	}
	internal sealed class Scalar : NodeEvent
	{
		internal override EventType Type => EventType.Scalar;

		public string Value { get; }

		public ScalarStyle Style { get; }

		public bool IsPlainImplicit { get; }

		public bool IsQuotedImplicit { get; }

		public override bool IsCanonical
		{
			get
			{
				if (!IsPlainImplicit)
				{
					return !IsQuotedImplicit;
				}
				return false;
			}
		}

		public 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);
		}
	}
	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);
		}
	}
	internal sealed class SequenceStart : NodeEvent
	{
		public override int NestingIncrease => 1;

		internal override EventType Type => EventType.SequenceStart;

		public bool IsImplicit { get; }

		public override bool IsCanonical => !IsImplicit;

		public SequenceStyle Style { get; }

		public SequenceStart(AnchorName anchor, TagName tag, bool isImplicit, SequenceStyle style, Mark start, Mark end)
			: base(anchor, tag, start, end)
		{
			IsImplicit = isImplicit;
			Style = style;
		}

		public SequenceStart(AnchorName anchor, TagName tag, bool isImplicit, SequenceStyle style)
			: this(anchor, tag, isImplicit, style, Mark.Empty, Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Sequence start [anchor = {base.Anchor}, tag = {base.Tag}, isImplicit = {IsImplicit}, style = {Style}]";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal enum SequenceStyle
	{
		Any,
		Block,
		Flow
	}
	internal sealed class StreamEnd : ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override EventType Type => EventType.StreamEnd;

		public StreamEnd(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);
		}
	}
	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.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
	{
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class DoesNotReturnAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class DoesNotReturnIfAttribute : Attribute
	{
		public bool ParameterValue { get; }

		public DoesNotReturnIfAttribute(bool parameterValue)
		{
			ParameterValue = parameterValue;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class MaybeNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class MaybeNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public MaybeNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class MemberNotNullAttribute : Attribute
	{
		public string[] Members { get; }

		public MemberNotNullAttribute(string member)
		{
			Members = new string[1] { member };
		}

		public MemberNotNullAttribute(params string[] members)
		{
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class MemberNotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public string[] Members { get; }

		public MemberNotNullWhenAttribute(bool returnValue, string member)
		{
			ReturnValue = returnValue;
			Members = new string[1] { member };
		}

		public MemberNotNullWhenAttribute(bool returnValue, params string[] members)
		{
			ReturnValue = returnValue;
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class NotNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Parameter | AttributeTargets.ReturnValue, AllowMultiple = true, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class NotNullIfNotNullAttribute : Attribute
	{
		public string ParameterName { get; }

		public NotNullIfNotNullAttribute(string parameterName)
		{
			ParameterName = parameterName;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class NotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public NotNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
}