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.Configs;
using Jotunn.Entities;
using Jotunn.Managers;
using LocalizationManager;
using Microsoft.CodeAnalysis;
using STUWard;
using ServerSync;
using Splatform;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
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("STUWard")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("sighsorry")]
[assembly: AssemblyProduct("STUWard")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("4358610B-F3F4-4843-B7AF-98B7BC60DCDE")]
[assembly: AssemblyFileVersion("1.3.1")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.3.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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]
	[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]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace LocalizationManager
{
	public static class Localizer
	{
		private static readonly string[] FileExtensions = new string[2] { ".json", ".yml" };

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

		private static readonly IDeserializer Deserializer = new DeserializerBuilder().IgnoreFields().Build();

		private static BaseUnityPlugin? _plugin;

		private static bool _registeredWithJotunn;

		private static bool _hookedJotunn;

		private static string? _lastLoggedAppliedLanguage;

		private static int _lastLoggedAppliedCount = -1;

		private static BaseUnityPlugin Plugin
		{
			get
			{
				//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00af: Expected O, but got Unknown
				if ((Object)(object)_plugin != (Object)null)
				{
					return _plugin;
				}
				IEnumerable<TypeInfo> source;
				try
				{
					source = Assembly.GetExecutingAssembly().DefinedTypes.ToList();
				}
				catch (ReflectionTypeLoadException ex)
				{
					source = from type in ex.Types
						where type != null
						select type.GetTypeInfo();
				}
				_plugin = (BaseUnityPlugin)Chainloader.ManagerObject.GetComponent((Type)source.First((TypeInfo type) => type.IsClass && typeof(BaseUnityPlugin).IsAssignableFrom(type)));
				return _plugin;
			}
		}

		private static CustomLocalization CustomLocalization => LocalizationManager.Instance.GetLocalization();

		public static event Action? OnLocalizationComplete;

		public static void Load()
		{
			_ = Plugin;
			LoadTranslations();
			RegisterWithJotunn();
			HookJotunn();
			ReloadCurrentLanguageIfAvailable();
			SafeCallLocalizeComplete();
		}

		public static void Unload()
		{
			if (_hookedJotunn)
			{
				LocalizationManager.OnLocalizationAdded -= ReloadCurrentLanguageIfAvailable;
				_hookedJotunn = false;
			}
			_plugin = null;
			_registeredWithJotunn = false;
			_lastLoggedAppliedLanguage = null;
			_lastLoggedAppliedCount = -1;
		}

		public static void ReloadCurrentLanguageIfAvailable()
		{
			if (Localization.instance != null)
			{
				LoadTranslations();
				RegisterWithJotunn();
				ApplyCurrentLanguage(Localization.instance);
			}
		}

		public static void LoadLocalizationLater()
		{
			ReloadCurrentLanguageIfAvailable();
		}

		public static void SafeCallLocalizeComplete()
		{
			Localizer.OnLocalizationComplete?.Invoke();
		}

		public static void AddText(string key, string text)
		{
			if (!CachedTranslations.TryGetValue("English", out Dictionary<string, string> value))
			{
				value = new Dictionary<string, string>(StringComparer.Ordinal);
				CachedTranslations["English"] = value;
			}
			value[key] = text;
			string text2 = "English";
			string text3 = key;
			CustomLocalization.ClearToken(ref text2, ref text3);
			CustomLocalization.AddTranslation(ref text2, ref text3, text);
			if (Localization.instance != null)
			{
				Localization.instance.AddWord(key, text);
			}
		}

		private static void LoadTranslations()
		{
			if (CachedTranslations.Count > 0)
			{
				return;
			}
			HashSet<string> availableLanguages = GetAvailableLanguages();
			Dictionary<string, string> dictionary = ReadMergedLanguage("English", null);
			if (dictionary == null || dictionary.Count == 0)
			{
				throw new InvalidOperationException("Found no English localizations in mod " + Plugin.Info.Metadata.Name + ". Expected translations/English.json or translations/English.yml.");
			}
			CachedTranslations["English"] = dictionary;
			foreach (string item in availableLanguages)
			{
				if (!item.Equals("English", StringComparison.OrdinalIgnoreCase))
				{
					Dictionary<string, string> dictionary2 = ReadMergedLanguage(item, dictionary);
					if (dictionary2 != null && dictionary2.Count > 0)
					{
						CachedTranslations[item] = dictionary2;
					}
				}
			}
			ManualLogSource log = STUWard.Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)("Loaded STUWard localizations: " + string.Join(", ", CachedTranslations.Select<KeyValuePair<string, Dictionary<string, string>>, string>((KeyValuePair<string, Dictionary<string, string>> kv) => $"{kv.Key}={kv.Value.Count}"))));
			}
		}

		private static void RegisterWithJotunn()
		{
			if (_registeredWithJotunn)
			{
				return;
			}
			_registeredWithJotunn = true;
			foreach (KeyValuePair<string, Dictionary<string, string>> cachedTranslation in CachedTranslations)
			{
				cachedTranslation.Deconstruct(out var key, out var value);
				string text = key;
				Dictionary<string, string> dictionary = new Dictionary<string, string>(value, StringComparer.Ordinal);
				CustomLocalization.AddTranslation(ref text, dictionary);
			}
			ManualLogSource log = STUWard.Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)("Registered STUWard localizations with Jotunn: " + string.Join(", ", CachedTranslations.Keys)));
			}
		}

		private static void HookJotunn()
		{
			if (!_hookedJotunn)
			{
				LocalizationManager.OnLocalizationAdded += ReloadCurrentLanguageIfAvailable;
				_hookedJotunn = true;
			}
		}

		private static void ApplyCurrentLanguage(Localization localization)
		{
			string selectedLanguage = localization.GetSelectedLanguage();
			Dictionary<string, string> translationsForLanguage = GetTranslationsForLanguage(selectedLanguage);
			foreach (var (text3, text4) in translationsForLanguage)
			{
				localization.AddWord(text3, text4);
			}
			if (!string.Equals(_lastLoggedAppliedLanguage, selectedLanguage, StringComparison.Ordinal) || _lastLoggedAppliedCount != translationsForLanguage.Count)
			{
				_lastLoggedAppliedLanguage = selectedLanguage;
				_lastLoggedAppliedCount = translationsForLanguage.Count;
				ManualLogSource log = STUWard.Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)$"Applied STUWard localization for language '{selectedLanguage}' with {translationsForLanguage.Count} entries.");
				}
			}
		}

		private static Dictionary<string, string> GetTranslationsForLanguage(string language)
		{
			if (CachedTranslations.TryGetValue(language, out Dictionary<string, string> value))
			{
				return value;
			}
			return CachedTranslations["English"];
		}

		private static HashSet<string> GetAvailableLanguages()
		{
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "English" };
			string[] manifestResourceNames = typeof(Localizer).Assembly.GetManifestResourceNames();
			foreach (string text in manifestResourceNames)
			{
				string[] fileExtensions = FileExtensions;
				foreach (string text2 in fileExtensions)
				{
					_ = "translations." + text2;
					if (!text.Contains(".translations.", StringComparison.OrdinalIgnoreCase) || !text.EndsWith(text2, StringComparison.OrdinalIgnoreCase))
					{
						continue;
					}
					int num = text.LastIndexOf(".translations.", StringComparison.OrdinalIgnoreCase);
					if (num >= 0)
					{
						int num2 = num + ".translations.".Length;
						int num3 = text.Length - num2 - text2.Length;
						if (num3 > 0)
						{
							hashSet.Add(text.Substring(num2, num3));
						}
					}
				}
			}
			foreach (string item in from path in Directory.GetFiles(Paths.PluginPath, Plugin.Info.Metadata.Name + ".*", SearchOption.AllDirectories)
				where FileExtensions.Contains<string>(Path.GetExtension(path), StringComparer.OrdinalIgnoreCase)
				select path)
			{
				string[] array = Path.GetFileNameWithoutExtension(item).Split('.');
				if (array.Length >= 2 && !string.IsNullOrWhiteSpace(array[1]))
				{
					hashSet.Add(array[1]);
				}
			}
			return hashSet;
		}

		private static Dictionary<string, string>? ReadMergedLanguage(string language, IReadOnlyDictionary<string, string>? englishFallback)
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.Ordinal);
			if (englishFallback != null)
			{
				MergeInto(dictionary, englishFallback);
			}
			Dictionary<string, string> dictionary2 = ReadEmbeddedLanguage(language);
			if (dictionary2 != null)
			{
				MergeInto(dictionary, dictionary2);
			}
			Dictionary<string, string> dictionary3 = ReadExternalLanguage(language);
			if (dictionary3 != null)
			{
				MergeInto(dictionary, dictionary3);
			}
			if (dictionary.Count != 0)
			{
				return dictionary;
			}
			return null;
		}

		private static Dictionary<string, string>? ReadEmbeddedLanguage(string language)
		{
			string[] fileExtensions = FileExtensions;
			foreach (string text in fileExtensions)
			{
				byte[] array = ReadEmbeddedFileBytes("translations." + language + text, typeof(Localizer).Assembly);
				if (array != null)
				{
					return DeserializeTranslations(Encoding.UTF8.GetString(array));
				}
			}
			return null;
		}

		private static Dictionary<string, string>? ReadExternalLanguage(string language)
		{
			string text = FindExternalLanguageFile(language);
			if (text != null)
			{
				return DeserializeTranslations(File.ReadAllText(text, Encoding.UTF8));
			}
			return null;
		}

		private static string? FindExternalLanguageFile(string language)
		{
			string[] fileExtensions = FileExtensions;
			foreach (string text in fileExtensions)
			{
				string searchPattern = Plugin.Info.Metadata.Name + "." + language + text;
				string text2 = Directory.GetFiles(Paths.PluginPath, searchPattern, SearchOption.AllDirectories).FirstOrDefault();
				if (!string.IsNullOrWhiteSpace(text2))
				{
					return text2;
				}
			}
			return null;
		}

		private static Dictionary<string, string> DeserializeTranslations(string rawText)
		{
			return Deserializer.Deserialize<Dictionary<string, string>>(rawText) ?? new Dictionary<string, string>(StringComparer.Ordinal);
		}

		private static void MergeInto(IDictionary<string, string> target, IReadOnlyDictionary<string, string> source)
		{
			foreach (KeyValuePair<string, string> item in source)
			{
				item.Deconstruct(out var key, out var value);
				string key2 = key;
				string value2 = value;
				target[key2] = value2;
			}
		}

		public static byte[]? ReadEmbeddedFileBytes(string resourceFileName, Assembly? containingAssembly = null)
		{
			using MemoryStream memoryStream = new MemoryStream();
			if ((object)containingAssembly == null)
			{
				containingAssembly = Assembly.GetCallingAssembly();
			}
			string text = containingAssembly.GetManifestResourceNames().FirstOrDefault((string name) => name.EndsWith(resourceFileName, StringComparison.OrdinalIgnoreCase));
			if (text == null)
			{
				return null;
			}
			containingAssembly.GetManifestResourceStream(text)?.CopyTo(memoryStream);
			return (memoryStream.Length == 0L) ? null : memoryStream.ToArray();
		}
	}
	public static class LocalizationManagerVersion
	{
		public const string Version = "1.4.1";
	}
}
namespace STUWard
{
	internal sealed class ConfigurationManagerAttributes
	{
		public int? Order;
	}
	[BepInPlugin("sighsorry.STUWard", "STUWard", "1.3.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public sealed class Plugin : BaseUnityPlugin
	{
		internal enum Toggle
		{
			Off,
			On
		}

		internal enum PickupBlockRule
		{
			BlockAllExceptWhitelist,
			AllowAllExceptBlacklist
		}

		internal enum HostileCreatureStructureProtectionMode
		{
			Off,
			UnattendedOnly,
			Always
		}

		internal enum RestrictionServerMode
		{
			NotForced,
			ForcedOn
		}

		internal enum BoundaryBrightenMode
		{
			Off,
			TrustedOnly,
			UntrustedOnly,
			All
		}

		internal const string ModName = "STUWard";

		internal const string ModVersion = "1.3.1";

		internal const string Author = "sighsorry";

		internal const string ModGuid = "sighsorry.STUWard";

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

		private Harmony _harmony;

		internal static ManualLogSource Log = null;

		internal static Plugin Instance = null;

		internal static ConfigEntry<Toggle> ServerConfigLocked = null;

		internal static ConfigEntry<int> MaxWardsPerSteamId = null;

		internal static ConfigEntry<float> MaxWardRadius = null;

		internal static ConfigEntry<PickupBlockRule> PickupBlockMode = null;

		internal static ConfigEntry<HostileCreatureStructureProtectionMode> HostileCreatureStructureProtection = null;

		internal static readonly Dictionary<WardRestrictionOptions, ConfigEntry<RestrictionServerMode>> RestrictionModes = new Dictionary<WardRestrictionOptions, ConfigEntry<RestrictionServerMode>>();

		internal static ConfigEntry<Toggle> DisableVanillaGuardStoneRecipe = null;

		internal static ConfigEntry<string> StuWardRecipe = null;

		internal static ConfigEntry<KeyboardShortcut> WardSettingsShortcut = null;

		internal static ConfigEntry<int> WardMinimapPinScale = null;

		internal static ConfigEntry<Toggle> WardMinimapActiveRanges = null;

		internal static ConfigEntry<BoundaryBrightenMode> WardBoundaryBrightenMode = null;

		private void Awake()
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			Instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			bool saveOnConfigSet = ((BaseUnityPlugin)this).Config.SaveOnConfigSet;
			((BaseUnityPlugin)this).Config.SaveOnConfigSet = false;
			try
			{
				WardPluginBootstrap.InitializeCore();
				WardPluginConfigBindings.BindAll();
				WardPluginBootstrap.InitializeFeatures();
				_harmony = new Harmony("sighsorry.STUWard");
				WardPatchRegistry.ApplyAll(_harmony);
				CreateOrReuseWardGuiController();
				((BaseUnityPlugin)this).Config.Save();
			}
			catch (Exception arg)
			{
				try
				{
					Harmony harmony = _harmony;
					if (harmony != null)
					{
						harmony.UnpatchSelf();
					}
				}
				catch (Exception ex)
				{
					Log.LogWarning((object)("Failed to remove Harmony patches after STUWard startup failure: " + ex.Message));
				}
				try
				{
					WardPluginBootstrap.Shutdown();
				}
				catch (Exception ex2)
				{
					Log.LogWarning((object)("Failed to shut down services after STUWard startup failure: " + ex2.Message));
				}
				Log.LogError((object)$"STUWard startup failed: {arg}");
				throw;
			}
			finally
			{
				((BaseUnityPlugin)this).Config.SaveOnConfigSet = saveOnConfigSet;
			}
		}

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

		private void OnDestroy()
		{
			WardPluginBootstrap.Shutdown();
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			((BaseUnityPlugin)this).Config.Save();
		}

		internal static bool IsWardSettingsShortcutDown()
		{
			//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_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			if (WardSettingsShortcut != null)
			{
				KeyboardShortcut value = WardSettingsShortcut.Value;
				if ((int)((KeyboardShortcut)(ref value)).MainKey != 0)
				{
					value = WardSettingsShortcut.Value;
					return ((KeyboardShortcut)(ref value)).IsDown();
				}
			}
			return false;
		}

		internal static bool HasWardSettingsShortcutBinding()
		{
			//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_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Invalid comparison between Unknown and I4
			if (WardSettingsShortcut != null)
			{
				KeyboardShortcut value = WardSettingsShortcut.Value;
				return (int)((KeyboardShortcut)(ref value)).MainKey > 0;
			}
			return false;
		}

		internal static string GetWardSettingsShortcutLabel()
		{
			//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_0014: 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_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_00a7: 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_00b0: Invalid comparison between Unknown and I4
			//IL_00e2: 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 (WardSettingsShortcut != null)
			{
				KeyboardShortcut value = WardSettingsShortcut.Value;
				if ((int)((KeyboardShortcut)(ref value)).MainKey != 0)
				{
					KeyboardShortcut value2 = WardSettingsShortcut.Value;
					List<string> list = new List<string>();
					AddModifierLabel(list, ((KeyboardShortcut)(ref value2)).Modifiers, (KeyCode)306, (KeyCode)305, "Ctrl");
					AddModifierLabel(list, ((KeyboardShortcut)(ref value2)).Modifiers, (KeyCode)308, (KeyCode)307, "Alt");
					AddModifierLabel(list, ((KeyboardShortcut)(ref value2)).Modifiers, (KeyCode)304, (KeyCode)303, "Shift");
					foreach (KeyCode modifier in ((KeyboardShortcut)(ref value2)).Modifiers)
					{
						if (modifier - 303 > 5)
						{
							list.Add(GetKeyLabel(modifier));
						}
					}
					list.Add(GetKeyLabel(((KeyboardShortcut)(ref value2)).MainKey));
					return string.Join("+", list);
				}
			}
			return WardLocalization.Localize("$stuw_shortcut_unbound", "Unbound");
		}

		private static void AddModifierLabel(List<string> parts, IEnumerable<KeyCode> modifiers, KeyCode left, KeyCode right, string label)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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)
			foreach (KeyCode modifier in modifiers)
			{
				if (modifier == left || modifier == right)
				{
					parts.Add(label);
					break;
				}
			}
		}

		private unsafe static string GetKeyLabel(KeyCode keyCode)
		{
			//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_0031: Expected I4, but got Unknown
			//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_0055: Expected I4, but got Unknown
			switch (keyCode - 48)
			{
			default:
				switch (keyCode - 303)
				{
				case 4:
				case 5:
					return "Alt";
				case 2:
				case 3:
					return "Ctrl";
				case 0:
				case 1:
					return "Shift";
				default:
					return ((object)(*(KeyCode*)(&keyCode))/*cast due to .constrained prefix*/).ToString();
				}
			case 0:
				return "0";
			case 1:
				return "1";
			case 2:
				return "2";
			case 3:
				return "3";
			case 4:
				return "4";
			case 5:
				return "5";
			case 6:
				return "6";
			case 7:
				return "7";
			case 8:
				return "8";
			case 9:
				return "9";
			}
		}

		internal static ConfigEntry<T> BindConfigEntry<T>(string group, string name, T value, string description, bool synchronizedSetting = true, int? configManagerOrder = null)
		{
			return Instance.BindConfig(group, name, value, description, synchronizedSetting, configManagerOrder);
		}

		private static WardGuiController CreateOrReuseWardGuiController()
		{
			//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_0023: Expected O, but got Unknown
			if ((Object)(object)WardGuiController.Instance != (Object)null)
			{
				return WardGuiController.Instance;
			}
			GameObject val = new GameObject("STUWard.WardGui");
			Object.DontDestroyOnLoad((Object)val);
			return val.AddComponent<WardGuiController>();
		}

		private ConfigEntry<T> BindConfig<T>(string group, string name, T value, string description, bool synchronizedSetting = true, int? configManagerOrder = null)
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			string text = (synchronizedSetting ? "Synced with server." : "Not synced with server.");
			string text2 = (string.IsNullOrWhiteSpace(description) ? text : (description.TrimEnd() + " " + text));
			ConfigDescription val = (configManagerOrder.HasValue ? new ConfigDescription(text2, (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = configManagerOrder.Value
				}
			}) : new ConfigDescription(text2, (AcceptableValueBase)null, Array.Empty<object>()));
			ConfigEntry<T> val2 = ((BaseUnityPlugin)this).Config.Bind<T>(group, name, value, val);
			if (synchronizedSetting)
			{
				ConfigSync.AddConfigEntry<T>(val2).SynchronizedConfig = true;
			}
			return val2;
		}
	}
	internal static class WardPluginBootstrap
	{
		internal static void InitializeCore()
		{
			Localizer.Load();
		}

		internal static void InitializeFeatures()
		{
			ManagedWardConfigFileService.Initialize();
			WardItemPrefabPolicy.Initialize();
			PrefabManager.OnVanillaPrefabsAvailable += RegisterStuWardPiece;
			RegisterStuWardPiece();
		}

		internal static void Shutdown()
		{
			PrefabManager.OnVanillaPrefabsAvailable -= RegisterStuWardPiece;
			DoorRpcUseDoorPatch.Reset();
			WardPluginConfigBindings.UnbindAll();
			WardItemPrefabPolicy.Shutdown();
			WardRecentPlayers.Shutdown();
			ManagedWardConfigFileService.Shutdown();
			GuildsCompat.TryShutdownHooks();
			Localizer.Unload();
		}

		private static void RegisterStuWardPiece()
		{
			StuWardPrefab.Register();
			StuWardPrefab.ApplyRecipeSettings();
		}
	}
	internal static class WardPluginConfigBindings
	{
		private static bool _handlersBound;

		private const int GeneralOrderStart = 700;

		private const int RestrictionOrderStart = 900;

		private const int ClientOrderStart = 300;

		private const int OrderStep = 10;

		internal static void BindAll()
		{
			UnbindAll();
			BindGeneral();
			BindRestrictions();
			BindClient();
			BindHandlers();
		}

		internal static void UnbindAll()
		{
			if (_handlersBound)
			{
				UnbindHandler<float>(Plugin.MaxWardRadius, HandleMaxWardRadiusChanged);
				UnbindHandler<Plugin.HostileCreatureStructureProtectionMode>(Plugin.HostileCreatureStructureProtection, HandleWardPresenceConfigChanged);
				UnbindHandler<Plugin.Toggle>(Plugin.DisableVanillaGuardStoneRecipe, HandleRecipeSettingsChanged);
				UnbindHandler<string>(Plugin.StuWardRecipe, HandleRecipeSettingsChanged);
				UnbindHandler<int>(Plugin.WardMinimapPinScale, HandleLocalWardPinConfigChanged);
				UnbindHandler<Plugin.Toggle>(Plugin.WardMinimapActiveRanges, HandleLocalWardPinConfigChanged);
				UnbindHandler<Plugin.BoundaryBrightenMode>(Plugin.WardBoundaryBrightenMode, HandleLocalBoundaryBrightenModeChanged);
				_handlersBound = false;
			}
		}

		private static void BindGeneral()
		{
			Plugin.ServerConfigLocked = Plugin.BindConfigEntry("1 - General", "Lock Configuration", Plugin.Toggle.On, "If on, the configuration is locked and can be changed by server admins only.", synchronizedSetting: true, 700);
			Plugin.ConfigSync.AddLockingConfigEntry<Plugin.Toggle>(Plugin.ServerConfigLocked);
			Plugin.MaxWardRadius = Plugin.BindConfigEntry("1 - General", "Max Ward Radius", 32f, "Maximum radius automatically assigned when a Ward is placed. Valid range: 8 to 64.", synchronizedSetting: true, 690);
			Plugin.MaxWardsPerSteamId = Plugin.BindConfigEntry("1 - General", "Max Wards Per Steam ID", 3, "Maximum number of managed Wards allowed per Steam/platform account. Set to -1 for unlimited.", synchronizedSetting: true, 680);
			Plugin.PickupBlockMode = Plugin.BindConfigEntry("1 - General", "Pickup Block Mode", Plugin.PickupBlockRule.BlockAllExceptWhitelist, "Pickup rule inside a foreign enabled ward. BlockAllExceptWhitelist blocks every item pickup except pickup_whitelist. AllowAllExceptBlacklist allows item pickup except pickup_blacklist.", synchronizedSetting: true, 670);
			Plugin.HostileCreatureStructureProtection = Plugin.BindConfigEntry("1 - General", "Hostile Creature Structure Protection Mode", Plugin.HostileCreatureStructureProtectionMode.UnattendedOnly, "Controls whether building pieces inside an enabled ward ignore damage from MonsterAI-controlled attackers. Off disables this extra protection. UnattendedOnly protects while no trusted player is nearby. Always protects regardless of trusted player presence. UnattendedOnly uses an 8 m trusted-player range buffer, 10 s grace time, and 1 s presence refresh.", synchronizedSetting: true, 660);
			Plugin.DisableVanillaGuardStoneRecipe = Plugin.BindConfigEntry("1 - General", "Disable Vanilla Guard Stone Recipe", Plugin.Toggle.On, "If on, the vanilla guard_stone build recipe is removed from the Hammer piece table while STUWard remains available.", synchronizedSetting: true, 650);
			Plugin.StuWardRecipe = Plugin.BindConfigEntry("1 - General", "STUWard Recipe", "GreydwarfEye:1,BoneFragments:3,Flint:5,Wood:7", "STUWard recipe override. Format: ItemPrefab:Amount[:Recover], ...", synchronizedSetting: true, 640);
		}

		private static void BindRestrictions()
		{
			Plugin.RestrictionModes.Clear();
			IReadOnlyList<WardRestrictionDefinition> restrictionDefinitions = WardSettings.RestrictionDefinitions;
			for (int i = 0; i < restrictionDefinitions.Count; i++)
			{
				WardRestrictionDefinition wardRestrictionDefinition = restrictionDefinitions[i];
				Plugin.RestrictionModes[wardRestrictionDefinition.Restriction] = BindRestrictionMode(wardRestrictionDefinition.ConfigName, wardRestrictionDefinition.ConfigDescription, 900 - i * 10);
			}
		}

		private static ConfigEntry<Plugin.RestrictionServerMode> BindRestrictionMode(string name, string description, int configManagerOrder)
		{
			return Plugin.BindConfigEntry("2 - Ward Restrictions", name + " Restriction", Plugin.RestrictionServerMode.ForcedOn, description + " ForcedOn preserves the server rule. NotForced lets each ward owner toggle this restriction in the ward settings UI.", synchronizedSetting: true, configManagerOrder);
		}

		private static void BindClient()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			Plugin.WardSettingsShortcut = Plugin.BindConfigEntry<KeyboardShortcut>("3 - Client", "Ward Settings Shortcut", new KeyboardShortcut((KeyCode)101, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }), "Shortcut used to open the ward settings UI while looking at your ward. Example values: LeftAlt + E, F7", synchronizedSetting: false, 300);
			Plugin.WardMinimapPinScale = Plugin.BindConfigEntry("3 - Client", "Ward Minimap Pin Scale", 1, "0 disables ward icon pins. 1 is the default icon size. 100 means x100 icon size.", synchronizedSetting: false, 290);
			Plugin.WardMinimapActiveRanges = Plugin.BindConfigEntry("3 - Client", "Ward Minimap Active Ranges", Plugin.Toggle.On, "If on, enabled managed wards also show their active radius on the minimap and map.", synchronizedSetting: false, 280);
			Plugin.WardBoundaryBrightenMode = Plugin.BindConfigEntry("3 - Client", "Ward Boundary Brighten Mode", Plugin.BoundaryBrightenMode.All, "Controls which enabled ward boundaries brighten near the local player. TrustedOnly applies to wards where the player is trusted, UntrustedOnly applies to wards where the player is not trusted, All applies to every ward, and Off disables the boundary cue. Placement-conflict highlights remain enabled in every mode.", synchronizedSetting: false, 270);
		}

		private static void BindHandlers()
		{
			BindHandler<float>(Plugin.MaxWardRadius, HandleMaxWardRadiusChanged);
			BindHandler<Plugin.HostileCreatureStructureProtectionMode>(Plugin.HostileCreatureStructureProtection, HandleWardPresenceConfigChanged);
			BindHandler<Plugin.Toggle>(Plugin.DisableVanillaGuardStoneRecipe, HandleRecipeSettingsChanged);
			BindHandler<string>(Plugin.StuWardRecipe, HandleRecipeSettingsChanged);
			BindHandler<int>(Plugin.WardMinimapPinScale, HandleLocalWardPinConfigChanged);
			BindHandler<Plugin.Toggle>(Plugin.WardMinimapActiveRanges, HandleLocalWardPinConfigChanged);
			BindHandler<Plugin.BoundaryBrightenMode>(Plugin.WardBoundaryBrightenMode, HandleLocalBoundaryBrightenModeChanged);
			_handlersBound = true;
		}

		private static void HandleMaxWardRadiusChanged(object? _, EventArgs __)
		{
			WardSettings.HandleMaxRadiusChanged();
		}

		private static void HandleWardPresenceConfigChanged(object? _, EventArgs __)
		{
			ManagedWardPresenceService.Invalidate();
		}

		private static void HandleRecipeSettingsChanged(object? _, EventArgs __)
		{
			StuWardPrefab.ApplyRecipeSettings();
		}

		private static void HandleLocalWardPinConfigChanged(object? _, EventArgs __)
		{
			WardMinimapPinsManager.HandleLocalConfigChanged();
		}

		private static void HandleLocalBoundaryBrightenModeChanged(object? _, EventArgs __)
		{
			WardSettings.HandleLocalBoundaryBrightenModeChanged();
		}

		private static void BindHandler<T>(ConfigEntry<T>? entry, EventHandler handler)
		{
			if (entry != null)
			{
				entry.SettingChanged += handler;
			}
		}

		private static void UnbindHandler<T>(ConfigEntry<T>? entry, EventHandler handler)
		{
			if (entry != null)
			{
				entry.SettingChanged -= handler;
			}
		}
	}
	internal readonly struct ManagedWardRef
	{
		internal PrivateArea? Area { get; }

		internal ZNetView? NView { get; }

		internal ZDO? Zdo { get; }

		internal StuWardArea? Component { get; }

		internal bool HasArea => (Object)(object)Area != (Object)null;

		internal bool HasManagedComponent => (Object)(object)Component != (Object)null;

		internal bool IsManagedZdo => WardOwnership.IsManagedWardZdo(Zdo);

		internal bool IsPlacementGhost
		{
			get
			{
				if ((Object)(object)Area != (Object)null)
				{
					return Player.IsPlacementGhost(((Component)Area).gameObject);
				}
				return false;
			}
		}

		internal bool HasValidNetworkIdentity
		{
			get
			{
				if ((Object)(object)NView != (Object)null && NView.IsValid())
				{
					return Zdo != null;
				}
				return false;
			}
		}

		internal bool IsOwner
		{
			get
			{
				if ((Object)(object)NView != (Object)null && NView.IsValid())
				{
					return NView.IsOwner();
				}
				return false;
			}
		}

		internal long CreatorPlayerId
		{
			get
			{
				ZDO? zdo = Zdo;
				if (zdo == null)
				{
					return 0L;
				}
				return zdo.GetLong(ZDOVars.s_creator, 0L);
			}
		}

		private ManagedWardRef(PrivateArea? area, ZNetView? nview, ZDO? zdo, StuWardArea? component)
		{
			Area = area;
			NView = nview;
			Zdo = zdo;
			Component = component;
		}

		internal static ManagedWardRef FromArea(PrivateArea? area)
		{
			return FromArea(area, null);
		}

		internal static ManagedWardRef FromArea(PrivateArea? area, ZDO? knownZdo)
		{
			ZNetView nView = WardPrivateAreaSafeAccess.GetNView(area);
			ZDO zdo = ((knownZdo != null && knownZdo.IsValid()) ? knownZdo : WardPrivateAreaSafeAccess.GetZdo(nView));
			return new ManagedWardRef(area, nView, zdo, ((Object)(object)area != (Object)null) ? ((Component)area).GetComponent<StuWardArea>() : null);
		}

		internal ManagedWardRef EnsureManagedComponent(out bool added)
		{
			added = false;
			if ((Object)(object)Area == (Object)null || HasManagedComponent || !IsManagedZdo || IsPlacementGhost)
			{
				return this;
			}
			((Component)Area).gameObject.AddComponent<StuWardArea>();
			added = true;
			return FromArea(Area, Zdo);
		}
	}
	internal sealed class ManagedWardIndex
	{
		private sealed class SpatialWardEntry
		{
			internal PrivateArea Area { get; }

			internal int InstanceId { get; }

			internal SpatialWardEntry(PrivateArea area)
			{
				Area = area;
				InstanceId = ((Object)area).GetInstanceID();
			}
		}

		private const float SpatialCellSize = 32f;

		private readonly Func<PrivateArea, bool> _isTrackable;

		private readonly List<PrivateArea> _areas = new List<PrivateArea>();

		private readonly HashSet<int> _areaIds = new HashSet<int>();

		private readonly Dictionary<long, List<SpatialWardEntry>> _spatialIndex = new Dictionary<long, List<SpatialWardEntry>>();

		private readonly Dictionary<int, List<long>> _spatialCellsByInstanceId = new Dictionary<int, List<long>>();

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

		private int _queryStamp;

		internal int Count => _areaIds.Count;

		internal ManagedWardIndex(Func<PrivateArea, bool> isTrackable)
		{
			_isTrackable = isTrackable;
		}

		internal bool Add(PrivateArea area)
		{
			int instanceID = ((Object)area).GetInstanceID();
			if (!_areaIds.Add(instanceID))
			{
				return false;
			}
			_areas.Add(area);
			return true;
		}

		internal bool Remove(PrivateArea area)
		{
			int instanceID = ((Object)area).GetInstanceID();
			if (!_areaIds.Remove(instanceID))
			{
				return false;
			}
			_areas.Remove(area);
			return true;
		}

		internal bool Contains(int instanceId)
		{
			return _areaIds.Contains(instanceId);
		}

		internal void Clear()
		{
			_areas.Clear();
			_areaIds.Clear();
			ClearSpatialIndex();
		}

		internal void ClearSpatialIndex()
		{
			_spatialIndex.Clear();
			_spatialCellsByInstanceId.Clear();
			_queryStamps.Clear();
			_queryStamp = 0;
		}

		internal void RebuildSpatialIndex()
		{
			ClearSpatialIndex();
			for (int i = 0; i < _areas.Count; i++)
			{
				PrivateArea val = _areas[i];
				if (_isTrackable(val))
				{
					AddAreaToSpatialIndex(val);
				}
			}
		}

		internal void UpdateSpatialIndex(PrivateArea area, int instanceId, bool shouldContain)
		{
			RemoveAreaFromSpatialIndex(instanceId);
			if (shouldContain && _isTrackable(area))
			{
				AddAreaToSpatialIndex(area);
			}
		}

		internal void FillCandidates(Vector3 point, float radius, List<PrivateArea> destination)
		{
			//IL_0027: 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_0042: 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)
			destination.Clear();
			if (_spatialIndex.Count == 0)
			{
				return;
			}
			int num = NextQueryStamp();
			float num2 = Mathf.Max(0f, radius);
			int spatialCellCoordinate = GetSpatialCellCoordinate(point.x - num2);
			int spatialCellCoordinate2 = GetSpatialCellCoordinate(point.x + num2);
			int spatialCellCoordinate3 = GetSpatialCellCoordinate(point.z - num2);
			int spatialCellCoordinate4 = GetSpatialCellCoordinate(point.z + num2);
			for (int i = spatialCellCoordinate; i <= spatialCellCoordinate2; i++)
			{
				for (int j = spatialCellCoordinate3; j <= spatialCellCoordinate4; j++)
				{
					if (!_spatialIndex.TryGetValue(GetSpatialCellKey(i, j), out List<SpatialWardEntry> value))
					{
						continue;
					}
					for (int k = 0; k < value.Count; k++)
					{
						SpatialWardEntry spatialWardEntry = value[k];
						if (!_queryStamps.TryGetValue(spatialWardEntry.InstanceId, out var value2) || value2 != num)
						{
							_queryStamps[spatialWardEntry.InstanceId] = num;
							destination.Add(spatialWardEntry.Area);
						}
					}
				}
			}
		}

		private void AddAreaToSpatialIndex(PrivateArea area)
		{
			//IL_0006: 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_002d: 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)
			Vector3 position = ((Component)area).transform.position;
			float radius = WardSettings.GetRadius(area);
			SpatialWardEntry spatialWardEntry = new SpatialWardEntry(area);
			List<long> list = new List<long>();
			int spatialCellCoordinate = GetSpatialCellCoordinate(position.x - radius);
			int spatialCellCoordinate2 = GetSpatialCellCoordinate(position.x + radius);
			int spatialCellCoordinate3 = GetSpatialCellCoordinate(position.z - radius);
			int spatialCellCoordinate4 = GetSpatialCellCoordinate(position.z + radius);
			for (int i = spatialCellCoordinate; i <= spatialCellCoordinate2; i++)
			{
				for (int j = spatialCellCoordinate3; j <= spatialCellCoordinate4; j++)
				{
					long spatialCellKey = GetSpatialCellKey(i, j);
					if (!_spatialIndex.TryGetValue(spatialCellKey, out List<SpatialWardEntry> value))
					{
						value = new List<SpatialWardEntry>();
						_spatialIndex[spatialCellKey] = value;
					}
					value.Add(spatialWardEntry);
					list.Add(spatialCellKey);
				}
			}
			_spatialCellsByInstanceId[spatialWardEntry.InstanceId] = list;
		}

		private void RemoveAreaFromSpatialIndex(int instanceId)
		{
			_queryStamps.Remove(instanceId);
			if (!_spatialCellsByInstanceId.TryGetValue(instanceId, out List<long> value))
			{
				return;
			}
			for (int i = 0; i < value.Count; i++)
			{
				long key = value[i];
				if (!_spatialIndex.TryGetValue(key, out List<SpatialWardEntry> value2))
				{
					continue;
				}
				for (int num = value2.Count - 1; num >= 0; num--)
				{
					if (value2[num].InstanceId == instanceId)
					{
						value2.RemoveAt(num);
					}
				}
				if (value2.Count == 0)
				{
					_spatialIndex.Remove(key);
				}
			}
			_spatialCellsByInstanceId.Remove(instanceId);
		}

		private static int GetSpatialCellCoordinate(float coordinate)
		{
			return Mathf.FloorToInt(coordinate / 32f);
		}

		private static long GetSpatialCellKey(int cellX, int cellZ)
		{
			return ((long)cellX << 32) ^ (uint)cellZ;
		}

		private int NextQueryStamp()
		{
			if (_queryStamp == int.MaxValue)
			{
				_queryStamp = 1;
				_queryStamps.Clear();
				return _queryStamp;
			}
			_queryStamp++;
			return _queryStamp;
		}
	}
	internal static class WardPatchRegistry
	{
		private static readonly HashSet<Type> OptionalPatchTypes = new HashSet<Type>
		{
			typeof(TameableCollectorCollectorItemPatch),
			typeof(AzuCraftyBoxesNearbyContainersPatch)
		};

		internal static void ApplyAll(Harmony harmony)
		{
			List<string> list = new List<string>();
			IReadOnlyList<Type> harmonyPatchTypes = GetHarmonyPatchTypes(Assembly.GetExecutingAssembly());
			for (int i = 0; i < harmonyPatchTypes.Count; i++)
			{
				if (!OptionalPatchTypes.Contains(harmonyPatchTypes[i]))
				{
					ApplyPatch(harmony, harmonyPatchTypes[i], required: true, list);
				}
			}
			if (list.Count != 0)
			{
				string text = "Failed to apply required patches: " + string.Join(", ", list);
				Plugin.Log.LogError((object)text);
				harmony.UnpatchSelf();
				throw new InvalidOperationException(text);
			}
			for (int j = 0; j < harmonyPatchTypes.Count; j++)
			{
				if (OptionalPatchTypes.Contains(harmonyPatchTypes[j]))
				{
					ApplyPatch(harmony, harmonyPatchTypes[j], required: false, list);
				}
			}
			PatchOptionalCompat("GuildsCompat", delegate
			{
				GuildsCompat.TryPatch(harmony);
			});
			PatchOptionalCompat("TargetPortalCompat", delegate
			{
				TargetPortalCompat.TryPatch(harmony);
			});
		}

		private static void ApplyPatch(Harmony harmony, Type patchType, bool required, ICollection<string> failedRequiredPatches)
		{
			try
			{
				harmony.CreateClassProcessor(patchType).Patch();
			}
			catch (Exception ex)
			{
				if (required)
				{
					failedRequiredPatches.Add(patchType.Name);
					Plugin.Log.LogError((object)("Failed to patch required " + patchType.Name + ": " + ex.GetType().Name + ": " + ex.Message));
				}
				else
				{
					Plugin.Log.LogWarning((object)("Failed to patch optional " + patchType.Name + ": " + ex.GetType().Name + ": " + ex.Message));
				}
			}
		}

		private static IReadOnlyList<Type> GetHarmonyPatchTypes(Assembly assembly)
		{
			List<Type> list = new List<Type>();
			foreach (Type loadableType in GetLoadableTypes(assembly))
			{
				if (loadableType.IsClass && HasHarmonyPatchAttribute(loadableType))
				{
					list.Add(loadableType);
				}
			}
			list.Sort((Type left, Type right) => string.Compare(left.FullName, right.FullName, StringComparison.Ordinal));
			return list;
		}

		private static void PatchOptionalCompat(string name, Action patchAction)
		{
			try
			{
				patchAction();
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Failed to patch " + name + ": " + ex.GetType().Name + ": " + ex.Message));
			}
		}

		private static bool HasHarmonyPatchAttribute(Type type)
		{
			return type.GetCustomAttributes(typeof(HarmonyPatch), inherit: false).Length != 0;
		}

		private static IEnumerable<Type> GetLoadableTypes(Assembly assembly)
		{
			try
			{
				return assembly.GetTypes();
			}
			catch (ReflectionTypeLoadException ex)
			{
				List<Type> list = new List<Type>();
				if (ex.Types == null)
				{
					return list;
				}
				for (int i = 0; i < ex.Types.Length; i++)
				{
					Type type = ex.Types[i];
					if (type != null)
					{
						list.Add(type);
					}
				}
				return list;
			}
		}
	}
	[DisallowMultipleComponent]
	internal sealed class StuWardArea : MonoBehaviour
	{
		internal const string PrefabName = "piece_stuward";

		internal const string BasePrefabName = "guard_stone";

		internal const string DisplayName = "$stuw_piece_name";

		internal const string Description = "$stuw_piece_desc";

		internal static bool IsManaged(PrivateArea? area)
		{
			if ((Object)(object)area != (Object)null)
			{
				return (Object)(object)((Component)area).GetComponent<StuWardArea>() != (Object)null;
			}
			return false;
		}
	}
	internal static class ManagedWardIdentity
	{
		internal static bool EnsureManagedComponent(PrivateArea? area)
		{
			return EnsureManagedComponent(ManagedWardRef.FromArea(area));
		}

		internal static bool EnsureManagedComponent(ManagedWardRef ward)
		{
			bool matchedByComponent;
			bool matchedByZdo;
			return TryResolve(ward, repairComponent: true, out matchedByComponent, out matchedByZdo) && matchedByComponent;
		}

		internal static bool TryResolve(PrivateArea? area, ZDO? zdo, bool repairComponent, out bool matchedByComponent, out bool matchedByZdo)
		{
			return TryResolve(ManagedWardRef.FromArea(area, zdo), repairComponent, out matchedByComponent, out matchedByZdo);
		}

		internal static bool TryResolve(ManagedWardRef ward, bool repairComponent, out bool matchedByComponent, out bool matchedByZdo)
		{
			matchedByComponent = ward.HasManagedComponent;
			matchedByZdo = ward.IsManagedZdo;
			if (!ward.HasArea)
			{
				return matchedByZdo;
			}
			if ((!matchedByComponent & matchedByZdo) && repairComponent)
			{
				matchedByComponent = ward.EnsureManagedComponent(out var _).HasManagedComponent;
			}
			return matchedByComponent | matchedByZdo;
		}
	}
	internal sealed class StuWardPlacedHook : MonoBehaviour, IPlaced
	{
		public void OnPlaced()
		{
			PrivateArea component = ((Component)this).GetComponent<PrivateArea>();
			ManagedWardRef ward = ManagedWardRef.FromArea(component);
			if (ManagedWardIdentity.EnsureManagedComponent(ward))
			{
				WardOwnership.TryStampLocalManagedWardOwnerAccount(ward);
				WardOwnership.NotifyServerManagedWardPlaced(ward);
				ManagedWardMapStateService.NotifyWardMutation(component);
			}
		}
	}
	internal static class StuWardPrefab
	{
		private static bool _registered;

		private static GameObject? _stuWardPrefab;

		private static GameObject? _vanillaGuardStonePrefab;

		private static int _vanillaGuardStoneIndex = -1;

		private static Requirement[]? _defaultStuWardRequirements;

		internal static void Register()
		{
			//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_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			if (_registered || PieceManager.Instance.GetPiece("piece_stuward") != null)
			{
				_registered = true;
			}
			else
			{
				if ((Object)(object)PrefabManager.Instance.GetPrefab("guard_stone") == (Object)null)
				{
					return;
				}
				PieceConfig val = new PieceConfig
				{
					PieceTable = "Hammer",
					Name = "$stuw_piece_name",
					Description = "$stuw_piece_desc"
				};
				CustomPiece val2 = new CustomPiece("piece_stuward", "guard_stone", val);
				GameObject piecePrefab = val2.PiecePrefab;
				Piece piece = val2.Piece;
				PrivateArea val3 = (((Object)(object)piecePrefab != (Object)null) ? piecePrefab.GetComponent<PrivateArea>() : null);
				if ((Object)(object)piecePrefab == (Object)null || (Object)(object)piece == (Object)null || (Object)(object)val3 == (Object)null)
				{
					Plugin.Log.LogWarning((object)"Failed to create STUWard clone prefab from guard_stone.");
					return;
				}
				if ((Object)(object)piecePrefab.GetComponent<StuWardArea>() == (Object)null)
				{
					piecePrefab.AddComponent<StuWardArea>();
				}
				if ((Object)(object)piecePrefab.GetComponent<StuWardPlacedHook>() == (Object)null)
				{
					piecePrefab.AddComponent<StuWardPlacedHook>();
				}
				piece.m_name = "$stuw_piece_name";
				piece.m_description = "$stuw_piece_desc";
				piece.m_resources = CloneRequirements(piece.m_resources);
				val3.m_name = "$stuw_piece_name";
				val3.m_radius = 8f;
				if ((Object)(object)val3.m_areaMarker != (Object)null)
				{
					val3.m_areaMarker.m_radius = 8f;
				}
				_stuWardPrefab = piecePrefab;
				_defaultStuWardRequirements = CloneRequirements(piece.m_resources);
				PieceManager.Instance.AddPiece(val2);
				_registered = PieceManager.Instance.GetPiece("piece_stuward") != null;
				if (_registered)
				{
					Plugin.Log.LogInfo((object)"Registered STUWard clone piece.");
				}
			}
		}

		internal static void ApplyRecipeSettings()
		{
			ApplyVanillaGuardStoneRecipeSetting();
			ApplyStuWardRecipeSetting();
		}

		internal static Sprite? GetPieceIcon()
		{
			Piece stuWardPiece = GetStuWardPiece();
			if ((Object)(object)stuWardPiece != (Object)null && (Object)(object)stuWardPiece.m_icon != (Object)null)
			{
				return stuWardPiece.m_icon;
			}
			CustomPiece piece = PieceManager.Instance.GetPiece("piece_stuward");
			if ((Object)(object)((piece != null) ? piece.Piece : null) != (Object)null && (Object)(object)piece.Piece.m_icon != (Object)null)
			{
				return piece.Piece.m_icon;
			}
			GameObject val = ((piece != null) ? piece.PiecePrefab : null) ?? PrefabManager.Instance.GetPrefab("piece_stuward") ?? PrefabManager.Instance.GetPrefab("guard_stone");
			Sprite val2 = ((!((Object)(object)val != (Object)null)) ? null : val.GetComponent<Piece>()?.m_icon);
			if ((Object)(object)val2 != (Object)null)
			{
				return val2;
			}
			return null;
		}

		internal static Requirement[] GetCurrentStuWardRequirements()
		{
			return CloneRequirements(GetStuWardPiece()?.m_resources);
		}

		private static Piece? GetStuWardPiece()
		{
			Piece val = (((Object)(object)_stuWardPrefab != (Object)null) ? _stuWardPrefab.GetComponent<Piece>() : null);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			CustomPiece piece = PieceManager.Instance.GetPiece("piece_stuward");
			if (piece == null)
			{
				return null;
			}
			return piece.Piece;
		}

		private static void ApplyVanillaGuardStoneRecipeSetting()
		{
			PieceTable? hammerPieceTable = GetHammerPieceTable();
			List<GameObject> list = hammerPieceTable?.m_pieces;
			GameObject prefab = PrefabManager.Instance.GetPrefab("guard_stone");
			if ((Object)(object)hammerPieceTable == (Object)null || list == null || (Object)(object)prefab == (Object)null)
			{
				return;
			}
			if (_vanillaGuardStonePrefab == null)
			{
				_vanillaGuardStonePrefab = prefab;
			}
			List<int> matchingGuardStoneIndexes = GetMatchingGuardStoneIndexes(list, prefab);
			if (_vanillaGuardStoneIndex < 0 && matchingGuardStoneIndexes.Count > 0)
			{
				_vanillaGuardStoneIndex = matchingGuardStoneIndexes[0];
			}
			if (Plugin.DisableVanillaGuardStoneRecipe != null && Plugin.DisableVanillaGuardStoneRecipe.Value == Plugin.Toggle.On)
			{
				for (int num = matchingGuardStoneIndexes.Count - 1; num >= 0; num--)
				{
					list.RemoveAt(matchingGuardStoneIndexes[num]);
				}
			}
			else if (matchingGuardStoneIndexes.Count == 0 && (Object)(object)_vanillaGuardStonePrefab != (Object)null)
			{
				int index = ((_vanillaGuardStoneIndex >= 0) ? Mathf.Clamp(_vanillaGuardStoneIndex, 0, list.Count) : list.Count);
				list.Insert(index, _vanillaGuardStonePrefab);
			}
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer != null)
			{
				localPlayer.UpdateAvailablePiecesList();
			}
		}

		private static void ApplyStuWardRecipeSetting()
		{
			Piece val = (((Object)(object)_stuWardPrefab != (Object)null) ? _stuWardPrefab.GetComponent<Piece>() : null);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			string text = Plugin.StuWardRecipe?.Value?.Trim() ?? string.Empty;
			Requirement[] requirements;
			if (string.IsNullOrWhiteSpace(text))
			{
				if (_defaultStuWardRequirements != null)
				{
					val.m_resources = CloneRequirements(_defaultStuWardRequirements);
					Player localPlayer = Player.m_localPlayer;
					if (localPlayer != null)
					{
						localPlayer.UpdateAvailablePiecesList();
					}
				}
			}
			else if (!TryParseRequirements(text, out requirements))
			{
				Plugin.Log.LogWarning((object)("Invalid STUWard recipe override '" + text + "'. Keeping previous recipe."));
			}
			else
			{
				val.m_resources = requirements;
				Player localPlayer2 = Player.m_localPlayer;
				if (localPlayer2 != null)
				{
					localPlayer2.UpdateAvailablePiecesList();
				}
			}
		}

		private static PieceTable? GetHammerPieceTable()
		{
			GameObject prefab = PrefabManager.Instance.GetPrefab("Hammer");
			return (((Object)(object)prefab != (Object)null) ? prefab.GetComponent<ItemDrop>() : null)?.m_itemData?.m_shared?.m_buildPieces;
		}

		private static List<int> GetMatchingGuardStoneIndexes(List<GameObject> pieces, GameObject guardStonePrefab)
		{
			List<int> list = new List<int>();
			for (int i = 0; i < pieces.Count; i++)
			{
				GameObject val = pieces[i];
				if (!((Object)(object)val == (Object)null) && ((Object)(object)val == (Object)(object)guardStonePrefab || ((Object)val).name == "guard_stone"))
				{
					list.Add(i);
				}
			}
			return list;
		}

		private static Requirement[] CloneRequirements(Requirement[]? source)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: 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_0049: 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_0062: Expected O, but got Unknown
			if (source == null || source.Length == 0)
			{
				return Array.Empty<Requirement>();
			}
			Requirement[] array = (Requirement[])(object)new Requirement[source.Length];
			for (int i = 0; i < source.Length; i++)
			{
				Requirement val = source[i];
				array[i] = new Requirement
				{
					m_resItem = val.m_resItem,
					m_amount = val.m_amount,
					m_extraAmountOnlyOneIngredient = val.m_extraAmountOnlyOneIngredient,
					m_amountPerLevel = val.m_amountPerLevel,
					m_recover = val.m_recover
				};
			}
			return array;
		}

		private static bool TryParseRequirements(string value, out Requirement[] requirements)
		{
			//IL_00eb: 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_00f8: 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: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Expected O, but got Unknown
			requirements = Array.Empty<Requirement>();
			string[] array = value.Split(new char[4] { ',', ';', '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
			if (array.Length == 0)
			{
				return false;
			}
			List<Requirement> list = new List<Requirement>(array.Length);
			string[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				string[] array3 = array2[i].Split(':');
				int num = array3.Length;
				if ((num < 2 || num > 3) ? true : false)
				{
					return false;
				}
				string text = array3[0].Trim();
				if (string.IsNullOrWhiteSpace(text) || !int.TryParse(array3[1], out var result) || result <= 0)
				{
					return false;
				}
				GameObject val = ResolveItemPrefab(text);
				ItemDrop val2 = (((Object)(object)val != (Object)null) ? val.GetComponent<ItemDrop>() : null);
				if ((Object)(object)val2 == (Object)null)
				{
					Plugin.Log.LogWarning((object)("Unable to resolve STUWard recipe item prefab '" + text + "'."));
					return false;
				}
				bool result2 = true;
				if (array3.Length == 3 && !TryParseBool(array3[2], out result2))
				{
					return false;
				}
				list.Add(new Requirement
				{
					m_resItem = val2,
					m_amount = result,
					m_amountPerLevel = 1,
					m_recover = result2
				});
			}
			requirements = list.ToArray();
			return true;
		}

		private static GameObject? ResolveItemPrefab(string prefabName)
		{
			if (string.IsNullOrWhiteSpace(prefabName))
			{
				return null;
			}
			ObjectDB instance = ObjectDB.instance;
			GameObject val = ((instance != null) ? instance.GetItemPrefab(prefabName) : null);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			return PrefabManager.Instance.GetPrefab(prefabName);
		}

		private static bool TryParseBool(string value, out bool result)
		{
			switch (value.Trim().ToLowerInvariant())
			{
			case "1":
			case "yes":
			case "on":
			case "true":
				result = true;
				return true;
			case "0":
			case "off":
			case "no":
			case "false":
				result = false;
				return true;
			default:
				result = false;
				return false;
			}
		}
	}
	[HarmonyPatch(typeof(ObjectDB), "Awake")]
	internal static class ObjectDBAwakePatch
	{
		private static void Postfix()
		{
			Localizer.ReloadCurrentLanguageIfAvailable();
			StuWardPrefab.ApplyRecipeSettings();
		}
	}
	[HarmonyPatch(typeof(ObjectDB), "CopyOtherDB")]
	internal static class ObjectDBCopyOtherDbPatch
	{
		private static void Postfix()
		{
			Localizer.ReloadCurrentLanguageIfAvailable();
			StuWardPrefab.ApplyRecipeSettings();
		}
	}
	internal readonly struct CachedWardGuildIdentity
	{
		internal bool HasGuild { get; }

		internal int GuildId { get; }

		internal string GuildName { get; }

		internal DateTime ExpiresAtUtc { get; }

		internal bool AuthoritativeNoGuild { get; }

		internal CachedWardGuildIdentity(bool hasGuild, int guildId, string guildName, DateTime expiresAtUtc, bool authoritativeNoGuild)
		{
			HasGuild = hasGuild;
			GuildId = guildId;
			GuildName = guildName;
			ExpiresAtUtc = expiresAtUtc;
			AuthoritativeNoGuild = authoritativeNoGuild;
		}
	}
	internal readonly struct WardGuildCharacterIdentity
	{
		internal long PlayerId { get; }

		internal string AccountId { get; }

		internal string PlayerName { get; }

		internal bool HasPlayerId => PlayerId != 0;

		internal bool HasAccountAndName
		{
			get
			{
				if (!string.IsNullOrWhiteSpace(AccountId))
				{
					return !string.IsNullOrWhiteSpace(PlayerName);
				}
				return false;
			}
		}

		internal WardGuildCharacterIdentity(long playerId, string accountId, string playerName)
		{
			PlayerId = playerId;
			AccountId = WardOwnership.NormalizeAccountIdValue(accountId);
			PlayerName = playerName?.Trim() ?? string.Empty;
		}
	}
	internal static class GuildsCompat
	{
		private enum AvailabilityState
		{
			Unknown,
			Available,
			Unavailable
		}

		private sealed class PendingWardGuildProjectionRefreshState
		{
			internal readonly HashSet<long> TargetPlayerIds = new HashSet<long>();

			internal readonly HashSet<string> TargetCharacterKeys = new HashSet<string>(StringComparer.Ordinal);

			internal readonly HashSet<int> AffectedGuildIds = new HashSet<int>();

			internal bool PendingFullRefresh;

			internal bool PendingLiveDisplayRefresh;

			internal DateTime FlushAtUtc = DateTime.MinValue;
		}

		internal const string GuildIdKey = "stuw_guild_id";

		internal const string GuildNameKey = "stuw_guild_name";

		private static readonly TimeSpan GuildLookupCacheDuration = TimeSpan.FromSeconds(30.0);

		private const string SyncPlayerGuildRpc = "STUWard_SyncPlayerGuild";

		private static readonly TimeSpan LocalGuildSyncHeartbeat = TimeSpan.FromSeconds(10.0);

		private static readonly Dictionary<long, SyncedWardGuildIdentity> ServerSyncedGuildByPlayerId = new Dictionary<long, SyncedWardGuildIdentity>();

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

		private static bool _syncRpcsRegistered;

		private static bool _localGuildSyncPending = true;

		private static long _lastSyncedLocalPlayerId;

		private static int _lastSyncedLocalGuildId = int.MinValue;

		private static string _lastSyncedLocalGuildName = string.Empty;

		private static DateTime _nextLocalGuildSyncUtc = DateTime.MinValue;

		private const string GuildsPluginGuid = "org.bepinex.plugins.guilds";

		private static readonly TimeSpan AvailabilityProbeBackoff = TimeSpan.FromSeconds(2.0);

		private static readonly Assembly? GuildsAssembly = GetPluginAssembly("org.bepinex.plugins.guilds");

		private static readonly Type? ApiType = GuildsAssembly?.GetType("Guilds.API");

		private static readonly Type? GuildType = GuildsAssembly?.GetType("Guilds.Guild");

		private static readonly Type? GuildGeneralType = GuildsAssembly?.GetType("Guilds.GuildGeneral");

		private static readonly Type? PlayerReferenceType = GuildsAssembly?.GetType("Guilds.PlayerReference");

		private static readonly Type? GuildJoinedDelegateType = ApiType?.GetNestedType("GuildJoined", BindingFlags.Public | BindingFlags.NonPublic);

		private static readonly Type? GuildLeftDelegateType = ApiType?.GetNestedType("GuildLeft", BindingFlags.Public | BindingFlags.NonPublic);

		private static readonly Type? GuildCreatedDelegateType = ApiType?.GetNestedType("GuildCreated", BindingFlags.Public | BindingFlags.NonPublic);

		private static readonly Type? GuildDeletedDelegateType = ApiType?.GetNestedType("GuildDeleted", BindingFlags.Public | BindingFlags.NonPublic);

		private static readonly MethodInfo? IsLoadedMethod = ((ApiType != null) ? AccessTools.Method(ApiType, "IsLoaded", (Type[])null, (Type[])null) : null);

		private static readonly MethodInfo? GetPlayerGuildByPlayerMethod = ((ApiType != null) ? AccessTools.Method(ApiType, "GetPlayerGuild", new Type[1] { typeof(Player) }, (Type[])null) : null);

		private static readonly MethodInfo? GetPlayerGuildByReferenceMethod = ((ApiType != null && PlayerReferenceType != null) ? AccessTools.Method(ApiType, "GetPlayerGuild", new Type[1] { PlayerReferenceType }, (Type[])null) : null);

		private static readonly MethodInfo? GetGuildByIdMethod = ((ApiType != null) ? AccessTools.Method(ApiType, "GetGuild", new Type[1] { typeof(int) }, (Type[])null) : null);

		private static readonly MethodInfo? PlayerReferenceFromStringMethod = ((PlayerReferenceType != null) ? AccessTools.Method(PlayerReferenceType, "fromString", new Type[1] { typeof(string) }, (Type[])null) : null);

		private static readonly MethodInfo? RegisterOnGuildJoinedMethod = ((ApiType != null && GuildJoinedDelegateType != null) ? AccessTools.Method(ApiType, "RegisterOnGuildJoined", new Type[1] { GuildJoinedDelegateType }, (Type[])null) : null);

		private static readonly MethodInfo? RegisterOnGuildLeftMethod = ((ApiType != null && GuildLeftDelegateType != null) ? AccessTools.Method(ApiType, "RegisterOnGuildLeft", new Type[1] { GuildLeftDelegateType }, (Type[])null) : null);

		private static readonly MethodInfo? RegisterOnGuildCreatedMethod = ((ApiType != null && GuildCreatedDelegateType != null) ? AccessTools.Method(ApiType, "RegisterOnGuildCreated", new Type[1] { GuildCreatedDelegateType }, (Type[])null) : null);

		private static readonly MethodInfo? RegisterOnGuildDeletedMethod = ((ApiType != null && GuildDeletedDelegateType != null) ? AccessTools.Method(ApiType, "RegisterOnGuildDeleted", new Type[1] { GuildDeletedDelegateType }, (Type[])null) : null);

		private static readonly MethodInfo? SaveGuildMethod = ((ApiType != null && GuildType != null) ? AccessTools.Method(ApiType, "SaveGuild", new Type[1] { GuildType }, (Type[])null) : null);

		private static readonly FieldInfo? GuildNameField = ((GuildType != null) ? AccessTools.Field(GuildType, "Name") : null);

		private static readonly FieldInfo? GuildGeneralField = ((GuildType != null) ? AccessTools.Field(GuildType, "General") : null);

		private static readonly FieldInfo? GuildGeneralIdField = ((GuildGeneralType != null) ? AccessTools.Field(GuildGeneralType, "id") : null);

		private static readonly FieldInfo? GuildMembersField = ((GuildType != null) ? AccessTools.Field(GuildType, "Members") : null);

		private static readonly FieldInfo? PlayerReferenceIdField = ((PlayerReferenceType != null) ? AccessTools.Field(PlayerReferenceType, "id") : null);

		private static readonly FieldInfo? PlayerReferenceNameField = ((PlayerReferenceType != null) ? (AccessTools.Field(PlayerReferenceType, "name") ?? AccessTools.Field(PlayerReferenceType, "Name")) : null);

		private static readonly bool HasGuildsApiSurface = ApiType != null && IsLoadedMethod != null;

		private static AvailabilityState _availabilityState = AvailabilityState.Unknown;

		private static DateTime _nextAvailabilityProbeUtc = DateTime.MinValue;

		private static readonly TimeSpan PendingWardGuildProjectionRefreshDebounce = TimeSpan.FromMilliseconds(250.0);

		private static readonly PendingWardGuildProjectionRefreshState PendingWardGuildProjectionRefresh = new PendingWardGuildProjectionRefreshState();

		private static readonly Dictionary<long, CachedWardGuildIdentity> PlayerGuildCache = new Dictionary<long, CachedWardGuildIdentity>();

		private static bool _guildHooksRegistered;

		private static bool _guildHooksActive;

		private static bool _saveGuildPatched;

		internal static void ResetRuntimeState()
		{
			PlayerGuildCache.Clear();
			ResetPendingWardGuildProjectionRefreshes();
			ResetSyncedGuildState();
			_availabilityState = AvailabilityState.Unknown;
			_nextAvailabilityProbeUtc = DateTime.MinValue;
		}

		internal static void EnsureRuntimeBindings()
		{
			RegisterSyncRpcs();
		}

		internal static WardGuildIdentity GetPlayerGuildIdentity(Player? player)
		{
			if (!TryGetGuild(player, out var guild))
			{
				return default(WardGuildIdentity);
			}
			return guild;
		}

		internal static WardGuildIdentity GetPlayerGuildIdentity(long playerId)
		{
			if (!TryGetGuild(playerId, out var guild))
			{
				return default(WardGuildIdentity);
			}
			return guild;
		}

		internal static int GetPlayerGuildId(Player? player)
		{
			if (!TryGetGuild(player, out var guild))
			{
				return 0;
			}
			return guild.Id;
		}

		internal static int GetPlayerGuildId(long playerId)
		{
			if (!TryGetGuild(playerId, out var guild))
			{
				return 0;
			}
			return guild.Id;
		}

		internal static string GetPlayerGuildName(long playerId)
		{
			if (!TryGetGuild(playerId, out var guild))
			{
				return string.Empty;
			}
			return guild.Name;
		}

		internal static int GetWardGuildId(ZDO? zdo)
		{
			if (zdo == null)
			{
				return 0;
			}
			return zdo.GetInt("stuw_guild_id", 0);
		}

		internal static string BuildCharacterIdentityKey(string accountId, string playerName)
		{
			string text = WardOwnership.NormalizeAccountIdValue(accountId);
			string text2 = playerName?.Trim() ?? string.Empty;
			if (string.IsNullOrWhiteSpace(text) || string.IsNullOrWhiteSpace(text2))
			{
				return string.Empty;
			}
			return text + "\n" + text2;
		}

		internal static void Update()
		{
			SyncLocalPlayerGuildIfNeeded(force: false);
			ProcessPendingWardGuildProjectionRefreshes();
		}

		internal static void OnLocalPlayerStarted(Player? player)
		{
			if (!((Object)(object)player == (Object)null) && !((Object)(object)player != (Object)(object)Player.m_localPlayer))
			{
				_localGuildSyncPending = true;
				SyncLocalPlayerGuildIfNeeded(force: true);
			}
		}

		internal static void ResetSyncedGuildState()
		{
			ServerSyncedGuildByPlayerId.Clear();
			ServerSyncedGuildByCharacterKey.Clear();
			_syncRpcsRegistered = false;
			_localGuildSyncPending = true;
			_lastSyncedLocalPlayerId = 0L;
			_lastSyncedLocalGuildId = int.MinValue;
			_lastSyncedLocalGuildName = string.Empty;
			_nextLocalGuildSyncUtc = DateTime.MinValue;
		}

		internal static bool TryGetSyncedGuildIdentity(long playerId, string accountId, string playerName, out WardGuildIdentity guild)
		{
			guild = default(WardGuildIdentity);
			if (playerId != 0L && ServerSyncedGuildByPlayerId.TryGetValue(playerId, out var value))
			{
				guild = (value.HasGuild ? new WardGuildIdentity(value.GuildId, value.GuildName) : default(WardGuildIdentity));
				return true;
			}
			string text = BuildCharacterIdentityKey(accountId, playerName);
			if (string.IsNullOrWhiteSpace(text) || !ServerSyncedGuildByCharacterKey.TryGetValue(text, out var value2))
			{
				return false;
			}
			guild = (value2.HasGuild ? new WardGuildIdentity(value2.GuildId, value2.GuildName) : default(WardGuildIdentity));
			return true;
		}

		internal static bool TryGetSyncedGuildIdentity(string accountId, string playerName, out WardGuildIdentity guild)
		{
			return TryGetSyncedGuildIdentity(0L, accountId, playerName, out guild);
		}

		private static void RegisterSyncRpcs()
		{
			ZRoutedRpc instance = ZRoutedRpc.instance;
			if (!_syncRpcsRegistered && instance != null)
			{
				instance.Register<ZPackage>("STUWard_SyncPlayerGuild", (Action<long, ZPackage>)HandleSyncPlayerGuild);
				_syncRpcsRegistered = true;
			}
		}

		private static void SyncLocalPlayerGuildIfNeeded(bool force)
		{
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Expected O, but got Unknown
			Player localPlayer = Player.m_localPlayer;
			ZNet instance = ZNet.instance;
			if ((Object)(object)localPlayer == (Object)null || (Object)(object)instance == (Object)null || !IsAvailable())
			{
				return;
			}
			long playerID = localPlayer.GetPlayerID();
			string playerAccountId = WardOwnership.GetPlayerAccountId(localPlayer);
			if (playerID == 0L || string.IsNullOrWhiteSpace(playerAccountId))
			{
				return;
			}
			WardGuildIdentity playerGuildIdentity = GetPlayerGuildIdentity(localPlayer);
			string text = playerGuildIdentity.Name ?? string.Empty;
			DateTime utcNow = DateTime.UtcNow;
			bool flag = !instance.IsServer() && utcNow >= _nextLocalGuildSyncUtc;
			bool flag2 = _localGuildSyncPending || playerID != _lastSyncedLocalPlayerId || playerGuildIdentity.Id != _lastSyncedLocalGuildId || !string.Equals(text, _lastSyncedLocalGuildName, StringComparison.Ordinal) || flag;
			if (!force && !flag2)
			{
				return;
			}
			if (instance.IsServer())
			{
				if (UpsertSyncedGuildIdentity(playerID, playerAccountId, localPlayer.GetPlayerName(), playerGuildIdentity, out var previousGuild))
				{
					RefreshWardGuildProjectionForCharacter(new WardGuildCharacterIdentity(playerID, playerAccountId, localPlayer.GetPlayerName()), liveDisplayRefresh: true, playerGuildIdentity.Id, previousGuild.Id);
				}
				RememberLocalGuildSync(playerID, playerGuildIdentity, utcNow);
				return;
			}
			ZRoutedRpc instance2 = ZRoutedRpc.instance;
			if (instance2 != null)
			{
				long serverPeerID = instance2.GetServerPeerID();
				if (serverPeerID != 0L)
				{
					ZPackage val = new ZPackage();
					val.Write(playerGuildIdentity.Id);
					val.Write(text);
					instance2.InvokeRoutedRPC(serverPeerID, "STUWard_SyncPlayerGuild", new object[1] { val });
					RememberLocalGuildSync(playerID, playerGuildIdentity, utcNow);
				}
			}
		}

		private static void HandleSyncPlayerGuild(long sender, ZPackage pkg)
		{
			if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer() && pkg != null && IsAvailable())
			{
				int reportedGuildId;
				string text;
				try
				{
					reportedGuildId = pkg.ReadInt();
					text = pkg.ReadString();
				}
				catch
				{
					return;
				}
				if (text.Length <= 256)
				{
					TryApplySyncedGuildIdentity(sender, reportedGuildId);
				}
			}
		}

		private static bool TryApplySyncedGuildIdentity(long sender, int reportedGuildId)
		{
			if (!WardOwnership.TryResolveAuthoritativePlayerIdFromSender(sender, out var playerId))
			{
				return false;
			}
			string text = WardOwnership.GetAuthoritativeAccountIdFromSender(sender, playerId);
			if (string.IsNullOrWhiteSpace(text))
			{
				text = WardOwnership.GetPlayerAccountId(playerId);
			}
			if (string.IsNullOrWhiteSpace(text))
			{
				return false;
			}
			string playerName = WardOwnership.GetPlayerName(playerId);
			if (!TryResolveAuthoritativeGuildIdentity(playerId, text, playerName, out var guild))
			{
				return false;
			}
			if (!GuildIdentityPolicy.CanApplyAuthoritativeGuild(reportedGuildId, guild.Id))
			{
				InvalidateSyncedGuildIdentity(new WardGuildCharacterIdentity(playerId, text, playerName));
				return false;
			}
			if (UpsertSyncedGuildIdentity(playerId, text, playerName, guild, out var previousGuild))
			{
				WardOwnership.RefreshServerPlayerAccountIdForResolvedPlayer(playerId, text);
				RefreshWardGuildProjectionForCharacter(new WardGuildCharacterIdentity(playerId, text, playerName), liveDisplayRefresh: true, guild.Id, previousGuild.Id);
			}
			return true;
		}

		private static void RememberLocalGuildSync(long playerId, WardGuildIdentity guild, DateTime sentAtUtc)
		{
			_lastSyncedLocalPlayerId = playerId;
			_lastSyncedLocalGuildId = guild.Id;
			_lastSyncedLocalGuildName = guild.Name ?? string.Empty;
			_localGuildSyncPending = false;
			_nextLocalGuildSyncUtc = sentAtUtc + LocalGuildSyncHeartbeat;
		}

		internal static void ForgetServerPlayerGuildIdentity(long playerId, string accountId, string playerName)
		{
			InvalidateSyncedGuildIdentity(new WardGuildCharacterIdentity(playerId, accountId, playerName));
		}

		internal static void InvalidateSyncedGuildIdentity(WardGuildCharacterIdentity identity)
		{
			HashSet<long> hashSet = new HashSet<long>();
			if (identity.HasPlayerId)
			{
				hashSet.Add(identity.PlayerId);
			}
			if (identity.HasAccountAndName)
			{
				foreach (KeyValuePair<long, SyncedWardGuildIdentity> item in ServerSyncedGuildByPlayerId)
				{
					if (string.Equals(item.Value.AccountId, identity.AccountId, StringComparison.Ordinal) && string.Equals(item.Value.PlayerName, identity.PlayerName, StringComparison.Ordinal))
					{
						hashSet.Add(item.Key);
					}
				}
			}
			foreach (long item2 in hashSet)
			{
				if (ServerSyncedGuildByPlayerId.Remove(item2, out var value))
				{
					RemoveSyncedGuildCharacterKey(value.AccountId, value.PlayerName);
				}
				PlayerGuildCache.Remove(item2);
			}
			RemoveSyncedGuildCharacterKey(identity.AccountId, identity.PlayerName);
		}

		internal static void InvalidateSyncedGuildIdentitiesForGuild(int guildId)
		{
			if (guildId == 0)
			{
				return;
			}
			List<WardGuildCharacterIdentity> list = new List<WardGuildCharacterIdentity>();
			foreach (KeyValuePair<long, SyncedWardGuildIdentity> item in ServerSyncedGuildByPlayerId)
			{
				if (item.Value.GuildId == guildId)
				{
					list.Add(new WardGuildCharacterIdentity(item.Key, item.Value.AccountId, item.Value.PlayerName));
				}
			}
			foreach (WardGuildCharacterIdentity item2 in list)
			{
				InvalidateSyncedGuildIdentity(item2);
			}
		}

		internal static void InvalidateAllSyncedGuildIdentities()
		{
			ServerSyncedGuildByPlayerId.Clear();
			ServerSyncedGuildByCharacterKey.Clear();
			PlayerGuildCache.Clear();
		}

		private static void RemoveSyncedGuildCharacterKey(string accountId, string playerName)
		{
			string text = BuildCharacterIdentityKey(accountId, playerName);
			if (!string.IsNullOrWhiteSpace(text))
			{
				ServerSyncedGuildByCharacterKey.Remove(text);
			}
		}

		private static void NotifyGuildProjectionRefreshApplied(bool fullRefresh, HashSet<long>? targetPlayerIds, HashSet<string>? targetCharacterKeys, HashSet<int>? affectedGuildIds)
		{
			HashSet<long> recipientPeerUids = null;
			if (!fullRefresh)
			{
				if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
				{
					return;
				}
				List<ZNetPeer> peers = ZNet.instance.GetPeers();
				recipientPeerUids = ((peers == null) ? new HashSet<long>() : CollectGuildProjectionRefreshRecipients(peers, targetPlayerIds, targetCharacterKeys, affectedGuildIds));
			}
			ManagedWardMapStateService.NotifyViewerProjectionChanged(fullRefresh, recipientPeerUids, refreshImmediatelyIfVisible: true);
		}

		private static HashSet<long> CollectGuildProjectionRefreshRecipients(List<ZNetPeer> peers, HashSet<long>? targetPlayerIds, HashSet<string>? targetCharacterKeys, HashSet<int>? affectedGuildIds)
		{
			HashSet<long> hashSet = new HashSet<long>();
			for (int i = 0; i < peers.Count; i++)
			{
				ZNetPeer val = peers[i];
				if (val != null && val.m_uid != 0L)
				{
					long playerIdFromSender = WardOwnership.GetPlayerIdFromSender(val.m_uid);
					string authoritativeAccountIdFromSender = WardOwnership.GetAuthoritativeAccountIdFromSender(val.m_uid, playerIdFromSender);
					string playerName = ((playerIdFromSender != 0L) ? WardOwnership.GetPlayerName(playerIdFromSender) : string.Empty);
					if (ShouldReceiveGuildProjectionRefresh(playerIdFromSender, authoritativeAccountIdFromSender, playerName, targetPlayerIds, targetCharacterKeys, affectedGuildIds))
					{
						hashSet.Add(val.m_uid);
					}
				}
			}
			return hashSet;
		}

		private static bool ShouldReceiveGuildProjectionRefresh(long playerId, string accountId, string playerName, HashSet<long>? targetPlayerIds, HashSet<string>? targetCharacterKeys, HashSet<int>? affectedGuildIds)
		{
			if (playerId != 0L && WardAdminDebugAccess.IsPlayerAdminDebugController(playerId))
			{
				return true;
			}
			if (targetPlayerIds != null && targetPlayerIds.Count > 0 && playerId != 0L && targetPlayerIds.Contains(playerId))
			{
				return true;
			}
			if (targetCharacterKeys != null && targetCharacterKeys.Count > 0)
			{
				string text = BuildCharacterIdentityKey(accountId, playerName);
				if (!string.IsNullOrWhiteSpace(text) && targetCharacterKeys.Contains(text))
				{
					return true;
				}
			}
			if (affectedGuildIds == null || affectedGuildIds.Count == 0)
			{
				return false;
			}
			WardGuildIdentity playerGuildIdentity = GetPlayerGuildIdentity(playerId);
			if (playerGuildIdentity.Id != 0)
			{
				return affectedGuildIds.Contains(playerGuildIdentity.Id);
			}
			return false;
		}

		private static bool UpsertSyncedGuildIdentity(long playerId, string accountId, string playerName, WardGuildIdentity guild, out WardGuildIdentity previousGuild)
		{
			previousGuild = default(WardGuildIdentity);
			bool result = false;
			SyncedWardGuildIdentity value = new SyncedWardGuildIdentity(guild.Id != 0, guild.Id, guild.Name, accountId, playerName);
			if (playerId != 0L)
			{
				if (ServerSyncedGuildByPlayerId.TryGetValue(playerId, out var value2))
				{
					previousGuild = ToWardGuildIdentity(value2);
					string text = BuildCharacterIdentityKey(value2.AccountId, value2.PlayerName);
					string b = BuildCharacterIdentityKey(value.AccountId, value.PlayerName);
					if (!string.Equals(text, b, StringComparison.Ordinal) && !string.IsNullOrWhiteSpace(text))
					{
						ServerSyncedGuildByCharacterKey.Remove(text);
					}
				}
				if (!ServerSyncedGuildByPlayerId.TryGetValue(playerId, out value2) || value2.HasGuild != value.HasGuild || value2.GuildId != value.GuildId || !string.Equals(value2.GuildName, value.GuildName, StringComparison.Ordinal) || !string.Equals(value2.AccountId, value.AccountId, StringComparison.Ordinal) || !string.Equals(value2.PlayerName, value.PlayerName, StringComparison.Ordinal))
				{
					ServerSyncedGuildByPlayerId[playerId] = value;
					result = true;
				}
			}
			string text2 = BuildCharacterIdentityKey(accountId, playerName);
			if (string.IsNullOrWhiteSpace(text2))
			{
				return result;
			}
			if (previousGuild.Id == 0 && ServerSyncedGuildByCharacterKey.TryGetValue(text2, out var value3))
			{
				previousGuild = ToWardGuildIdentity(value3);
			}
			if (!ServerSyncedGuildByCharacterKey.TryGetValue(text2, out var value4) || value4.HasGuild != value.HasGuild || value4.GuildId != value.GuildId || !string.Equals(value4.GuildName, value.GuildName, StringComparison.Ordinal))
			{
				ServerSyncedGuildByCharacterKey[text2] = value;
				result = true;
			}
			return result;
		}

		private static WardGuildIdentity ToWardGuildIdentity(SyncedWardGuildIdentity syncedGuild)
		{
			if (!syncedGuild.HasGuild)
			{
				return default(WardGuildIdentity);
			}
			return new WardGuildIdentity(syncedGuild.GuildId, syncedGuild.GuildName);
		}

		private static Assembly? GetPluginAssembly(string pluginGuid)
		{
			if (!Chainloader.PluginInfos.TryGetValue(pluginGuid, out var value))
			{
				return null;
			}
			return ((object)value.Instance)?.GetType().Assembly;
		}

		internal static bool IsAvailable()
		{
			if (!HasGuildsApiSurface)
			{
				return false;
			}
			if (_availabilityState == AvailabilityState.Available)
			{
				return true;
			}
			DateTime utcNow = DateTime.UtcNow;
			if (_availabilityState == AvailabilityState.Unavailable && utcNow < _nextAvailabilityProbeUtc)
			{
				return false;
			}
			try
			{
				if (IsLoadedMethod.Invoke(null, Array.Empty<object>()) as bool? == true)
				{
					_availabilityState = AvailabilityState.Available;
					_nextAvailabilityProbeUtc = DateTime.MaxValue;
					return true;
				}
			}
			catch
			{
			}
			_availabilityState = AvailabilityState.Unavailable;
			_nextAvailabilityProbeUtc = utcNow + AvailabilityProbeBackoff;
			return false;
		}

		internal static void ResetPendingWardGuildProjectionRefreshes()
		{
			PendingWardGuildProjectionRefresh.TargetPlayerIds.Clear();
			PendingWardGuildProjectionRefresh.TargetCharacterKeys.Clear();
			PendingWardGuildProjectionRefresh.AffectedGuildIds.Clear();
			PendingWardGuildProjectionRefresh.PendingFullRefresh = false;
			PendingWardGuildProjectionRefresh.PendingLiveDisplayRefresh = false;
			PendingWardGuildProjectionRefresh.FlushAtUtc = DateTime.MinValue;
		}

		internal static int GetWardGuildId(PrivateArea? area)
		{
			if (TryGetStoredWardGuildIdentity(GetWardZdo(area), out var guild))
			{
				return guild.Id;
			}
			if (!TryResolveWardGuildIdentity(area, out var guild2))
			{
				return 0;
			}
			return guild2.Id;
		}

		internal static string GetWardGuildName(PrivateArea? area)
		{
			if (TryGetStoredWardGuildIdentity(GetWardZdo(area), out var guild) && !string.IsNullOrWhiteSpace(guild.Name))
			{
				return guild.Name;
			}
			if (TryResolveWardGuildIdentity(area, out var guild2))
			{
				return guild2.Name;
			}
			int id = guild.Id;
			if (id != 0 && TryGetGuildById(id, out guild2))
			{
				return guild2.Name;
			}
			Player localPlayer = Player.m_localPlayer;
			if (id != 0 && (Object)(object)localPlayer != (Object)null && TryGetGuild(localPlayer, out guild2) && guild2.Id == id)
			{
				return guild2.Name;
			}
			return string.Empty;
		}

		internal static WardGuildIdentity ResolveWardGuildIdentityReadOnly(ZDO? zdo)
		{
			if (TryGetStoredWardGuildIdentity(zdo, out var guild) && guild.Id != 0)
			{
				return guild;
			}
			if (zdo == null)
			{
				return default(WardGuildIdentity);
			}
			long num = zdo.GetLong(ZDOVars.s_creator, 0L);
			string wardSteamAccountId = WardOwnership.ResolveWardSteamAccountId(zdo, num);
			string wardOwnerNameForProjection = GetWardOwnerNameForProjection(zdo);
			if (!TryResolveWardGuildIdentityReadOnly(num, wardSteamAccountId, wardOwnerNameForProjection, treatResolvedNoGuildAsResolved: false, out var guild2))
			{
				return default(WardGuildIdentity);
			}
			return guild2;
		}

		private static bool TryGetStoredWardGuildIdentity(ZDO? zdo, out WardGuildIdentity guild)
		{
			guild = default(WardGuildIdentity);
			if (zdo == null)
			{
				return false;
			}
			int num = zdo.GetInt("stuw_guild_id", 0);
			string text = zdo.GetString("stuw_guild_name", string.Empty) ?? string.Empty;
			if (num == 0 && string.IsNullOrWhiteSpace(text))
			{
				return false;
			}
			guild = new WardGuildIdentity(num, text.Trim());
			return true;
		}

		private static ZDO? GetWardZdo(PrivateArea? area)
		{
			return WardPrivateAreaSafeAccess.GetZdo(area);
		}

		private static bool TryResolveWardGuildIdentity(PrivateArea? area, out WardGuildIdentity guild)
		{
			guild = default(WardGuildIdentity);
			if ((Object)(object)area == (Object)null)
			{
				return false;
			}
			ZDO? wardZdo = GetWardZdo(area);
			long canonicalCreatorPlayerId = WardAccess.GetCanonicalCreatorPlayerId(area);
			string wardSteamAccountId = WardOwnership.ResolveWardSteamAccountId(wardZdo, canonicalCreatorPlayerId);
			string wardOwnerNameForProjection = GetWardOwnerNameForProjection(wardZdo);
			if (TryResolveWardGuildIdentityReadOnly(canonicalCreatorPlayerId, wardSteamAccountId, wardOwnerNameForProjection, treatResolvedNoGuildAsResolved: true, out guild))
			{
				return true;
			}
			return false;
		}

		internal static string GetWardOwnerNameForProjection(ZDO? zdo)
		{
			return WardPrivateAreaSafeAccess.GetCreatorName(zdo);
		}

		internal static bool TryResolveProjectedGuildIdentity(long ownerPlayerId, string normalizedAccountId, string ownerName, out WardGuildIdentity guild)
		{
			return TryResolveWardGuildIdentityReadOnly(ownerPlayerId, normalizedAccountId, ownerName, treatResolvedNoGuildAsResolved: true, out guild);
		}

		private static bool TryResolveWardGuildIdentityReadOnly(long ownerPlayerId, string wardSteamAccountId, string ownerName, bool treatResolvedNoGuildAsResolved, out WardGuildIdentity guild)
		{
			guild = default(WardGuildIdentity);
			string text = WardOwnership.NormalizeAccountIdValue(wardSteamAccountId);
			string text2 = ownerName?.Trim() ?? string.Empty;
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
			{
				if (TryGetSyncedGuildIdentity(ownerPlayerId, text, text2, out guild))
				{
					if (!treatResolvedNoGuildAsResolved)
					{
						return guild.Id != 0;
					}
					return true;
				}
				if (TryResolveAuthoritativeGuildIdentity(ownerPlayerId, text, text2, out guild))
				{
					if (!treatResolvedNoGuildAsResolved)
					{
						return guild.Id != 0;
					}
					return true;
				}
				return false;
			}
			if (ownerPlayerId != 0L && TryGetGuild(ownerPlayerId, out guild))
			{
				return true;
			}
			if (!string.IsNullOrWhiteSpace(text) && !string.IsNullOrWhiteSpace(text2))
			{
				return TryGetGuildByAccountAndName(text, text2, out guild);
			}
			return false;
		}

		internal static void HandleGuildSaved(object? guild)
		{
			RefreshWardGuildProjectionForGuild(guild);
		}

		internal static void RefreshAllWardGuildProjections(bool liveDisplayRefresh = false)
		{
			InvalidateAllSyncedGuildIdentities();
			QueueWardGuildProjectionRefreshForAll(liveDisplayRefresh);
		}

		private static void RefreshWardGuildProjectionForGuild(object? guild)
		{
			WardGuildIdentity guild2;
			int num = (TryParseGuild(guild, out guild2) ? guild2.Id : 0);
			InvalidateSyncedGuildIdentitiesForGuild(num);
			bool hadUnresolvedMembers;
			List<WardGuildCharacterIdentity> list = CollectGuildMemberCharacterIdentities(guild, out hadUnresolvedMembers);
			if (list.Count == 0 || hadUnresolvedMembers)
			{
				QueueWardGuildProjectionRefreshForAll(liveDisplayRefresh: false);
				return;
			}
			foreach (WardGuildCharacterIdentity item in list)
			{
				InvalidateSyncedGuildIdentity(item);
				RefreshWardGuildProjectionForCharacter(item, liveDisplayRefresh: false, num);
			}
		}

		private static void RefreshWardGuildProjectionForCharacter(WardGuildCharacterIdentity identity, bool liveDisplayRefresh = false, int affectedGuildId = 0, int previousGuildId = 0)
		{
			if (identity.HasPlayerId || identity.HasAccountAndName)
			{
				if (!string.IsNullOrWhiteSpace(identity.AccountId))
				{
					InvalidateGuildCacheForAccountId(identity.AccountId);
				}
				QueueWardGuildProjectionRefreshForCharacter(identity, liveDisplayRefresh, affectedGuildId, previousGuildId);
			}
		}

		internal static void ProcessPendingWardGuildProjectionRefreshes()
		{
			PendingWardGuildProjectionRefreshState pendingWardGuildProjectionRefresh = PendingWardGuildProjectionRefresh;
			if ((pendingWardGuildProjectionRefresh.PendingFullRefresh || pendingWardGuildProjectionRefresh.TargetPlayerIds.Count != 0 || pendingWardGuildProjectionRefresh.TargetCharacterKeys.Count != 0 || pendingWardGuildProjectionRefresh.AffectedGuildIds.Count != 0) && !((Object)(object)ZNet.instance == (Object)null))
			{
				if (!ZNet.instance.IsServer())
				{
					ResetPendingWardGuildProjectionRefreshes();
				}
				else if (!(pendingWardGuildProjectionRefresh.FlushAtUtc > DateTime.UtcNow))
				{
					bool pendingFullRefresh = pendingWardGuildProjectionRefresh.PendingFullRefresh;
					bool pendingLiveDisplayRefresh = pendingWardGuildProjectionRefresh.PendingLiveDisplayRefresh;
					HashSet<long> targetPlayerIds = ((pendingWardGuildProjectionRefresh.TargetPlayerIds.Count == 0) ? null : new HashSet<long>(pendingWardGuildProjectionRefresh.TargetPlayerIds));
					HashSet<string> targetCharacterKeys = ((pendingWardGuildProjectionRefresh.TargetCharacterKeys.Count == 0) ? null : new HashSet<string>(pendingWardGuildProjectionRefresh.TargetCharacterKeys, StringComparer.Ordinal));
					HashSet<int> affectedGuildIds = ((pendingWardGuildProjectionRefresh.AffectedGuildIds.Count == 0) ? null : new HashSet<int>(pendingWardGuildProjectionRefresh.AffectedGuildIds));
					ResetPendingWardGuildProjectionRefreshes();
					RefreshWardGuildProjectionForManagedWards(targetPlayerIds, targetCharacterKeys, affectedGuildIds, pendingFullRefresh, pendingLiveDisplayRefresh);
				}
			}
		}

		private static void QueueWardGuildProjectionRefreshForAll(bool liveDisplayRefresh)
		{
			if ((Object)(object)ZNet.instance != (Object)null && !ZNet.instance.IsServer())
			{
				if (liveDisplayRefresh)
				{
					ManagedWardMapStateService.RequestLocalDisplayRefresh(refreshImmediatelyIfVisible: true);
				}
			}
			else
			{
				PendingWardGuildProjectionRefresh.PendingFullRefresh = true;
				PendingWardGuildProjectionRefresh.TargetPlayerIds.Clear();
				PendingWardGuildProjectionRefresh.TargetCharacterKeys.Clear();
				UpdatePendingWardGuildProjectionRefreshWindow(liveDisplayRefresh);
			}
		}

		private static void QueueWardGuildProjectionRefreshForCharacter(WardGuildCharacterIdentity identity, bool liveDisplayRefresh, int affectedGuildId, int previousGuildId)
		{
			if ((Object)(object)ZNet.instance != (Object)null && !ZNet.instance.IsServer())
			{
				if (liveDisplayRefresh)
				{
					ManagedWardMapStateService.RequestLocalDisplayRefresh(refreshImmediatelyIfVisible: true);
				}
				return;
			}
			if (!PendingWardGuildProjectionRefresh.PendingFullRefresh)
			{
				if (identity.HasPlayerId)
				{
					PendingWardGuildProjectionRefresh.TargetPlayerIds.Add(identity.PlayerId);
				}
				if (identity.HasAccountAndName)
				{
					string text = BuildCharacterIdentityKey(identity.AccountId, identity.PlayerName);
					if (!string.IsNullOrWhiteSpace(text))
					{
						PendingWardGuildProjectionRefresh.TargetCharacterKeys.Add(text);
					}
				}
			}
			if (affectedGuildId != 0)
			{
				PendingWardGuildProjectionRefresh.AffectedGuildIds.Add(affectedGuildId);
			}
			if (previousGuildId != 0)
			{
				PendingWardGuildProjectionRefresh.AffectedGuildIds.Add(previousGuildId);
			}
			UpdatePendingWardGuildProjectionRefreshWindow(liveDisplayRefresh);
		}

		private static void UpdatePendingWardGuildProjectionRefreshWindow(bool liveDisplayRefresh)
		{
			if (liveDisplayRefresh)
			{
				PendingWardGuildProjectionRefresh.PendingLiveDisplayRefresh = true;
			}
			if (PendingWardGuildProjectionRefresh.FlushAtUtc == DateTime.MinValue)
			{
				PendingWardGuildProjectionRefresh.FlushAtUtc = DateTime.UtcNow + PendingWardGuildProjectionRefreshDebounce;
			}
		}

		private static void RefreshWardGuildProjectionForManagedWards(HashSet<long>? targetPlayerIds, HashSet<string>? targetCharacterKeys, HashSet<int>? affectedGuildIds, bool fullRefresh, bool liveDisplayRefresh)
		{
			//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_007c: 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)
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || (!fullRefresh && (targetPlayerIds == null || targetPlayerIds.Count == 0) && (targetCharacterKeys == null || targetCharacterKeys.Count == 0) && (affectedGuildIds == null || affectedGuildIds.Count == 0)))
			{
				return;
			}
			if (fullRefresh)
			{
				InvalidateAllGuildCaches();
			}
			HashSet<ZDOID> hashSet = new HashSet<ZDOID>();
			ManagedWardRegistry.CollectCandidateIds(hashSet, targetPlayerIds, targetCharacterKeys, affectedGuildIds, fullRefresh);
			WardPermittedSnapshots.RefreshKnownSnapshotsForGuildIdentityChanges(targetPlayerIds, targetCharacterKeys, affectedGuildIds, fullRefresh);
			foreach (ZDOID item in hashSet)
			{
				ZDOMan instance = ZDOMan.instance;
				ZDO val = ((instance != null) ? instance.GetZDO(item) : null);
				if (val == null || !WardOwnership.IsManagedWardZdo(val))
				{
					ManagedWardRegistry.RemoveEntry(item);
					continue;
				}
				long num = val.GetLong(ZDOVars.s_creator, 0L);
				string wardSteamAccountId = WardOwnership.NormalizeAccountIdValue(WardOwnership.ResolveWardSteamAccountId(val, num));
				ManagedWardProjectionService.RefreshProjectedMetadata(val, num, wardSteamAccountId);
			}
			if (liveDisplayRefresh)
			{
				NotifyGuildProjectionRefreshApplied(fullRefresh, targetPlayerIds, targetCharacterKeys, affectedGuildIds);
			}
		}

		private static List<WardGuildCharacterIdentity> CollectGuildMemberCharacterIdentities(object? guild, out bool hadUnresolvedMembers)
		{
			Dictionary<string, WardGuildCharacterIdentity> dictionary = new Dictionary<string, WardGuildCharacterIdentity>(StringComparer.Ordinal);
			hadUnresolvedMembers = false;
			if (guild == null || GuildMembersField == null)
			{
				return new List<WardGuildCharacterIdentity>();
			}
			object value = GuildMembersField.GetValue(guild);
			if (value is IDictionary dictionary2)
			{
				foreach (object key in dictionary2.Keys)
				{
					if (!TryCreateCharacterIdentityFromPlayerReference(key, out var identity))
					{
						hadUnresolvedMembers = true;
					}
					else
					{
						dictionary[BuildCharacterIdentityKey(identity.AccountId, identity.PlayerName)] = identity;
					}
				}
				return new List<WardGuildCharacterIdentity>(dictionary.Values);
			}
			if (!(value is IEnumerable enumerable))
			{
				return new List<WardGuildCharacterIdentity>();
			}
			foreach (object item in enumerable)
			{
				if (item != null)
				{
					if (!TryCreateCharacterIdentityFromPlayerReference(AccessTools.Property(item.GetType(), "Key")?.GetValue(item, null), out var identity2))
					{
						hadUnresolvedMembers = true;
					}
					else
					{
						dictionary[BuildCharacterIdentityKey(identity2.AccountId, identity2.PlayerName)] = identity2;
					}
				}
			}
			return new List<WardGuildCharacterIdentity>(dictionary.Values);
		}

		private static bool TryCreateCharacterIdentityFromPlayerReference(object? playerReference, out WardGuildCharacterIdentity identity)
		{
			identity = default(WardGuildCharacterIdentity);
			if (playerReference == null || PlayerReferenceIdField == null)
			{
				return false;
			}
			try
			{
				string text = WardOwnership.NormalizeAccountIdValue(PlayerReferenceIdField.GetValue(playerReference)?.ToString());
				string playerNameFromPlayerReference = GetPlayerNameFromPlayerReference(playerReference);
				if (string.IsNullOrWhiteSpace(text) || string.IsNullOrWhiteSpace(playerNameFromPlayerReference))
				{
					return false;
				}
				identity = new WardGuildCharacterIdentity(0L, text, playerNameFromPlayerReference);
				return true;
			}
			catch
			{
				return false;
			}
		}

		private static string GetPlayerNameFromPlayerReference(object playerReference)
		{
			if (PlayerReferenceNameField != null)
			{
				string text = PlayerReferenceNameField.GetValue(playerReference)?.ToString()?.Trim() ?? string.Empty;
				if (!string.IsNullOrWhiteSpace(text))
				{
					return text;
				}
			}
			string text2 = playerReference.ToString()?.Trim() ?? string.Empty;
			int num = text2.IndexOf(':');
			if (num < 0 || num >= text2.Length - 1)
			{
				return string.Empty;
			}
			return text2.Substring(num + 1).Trim();
		}

		private static void InvalidateGuildCacheForAccountId(string accountId)
		{
			string text = WardOwnership.NormalizeAccountIdValue(accountId);
			if (string.IsNullOrWhiteSpace(text))
			{
				return;
			}
			HashSet<long> hashSet = new HashSet<long>();
			foreach (KeyValuePair<long, CachedWardGuildIdentity> item in PlayerGuildCache)
			{
				if (string.Equals(WardOwnership.NormalizeAccountIdValue(WardOwnership.GetPlayerAccountId(item.Key)), text, StringComparison.Ordinal))
				{
					hashSet.Add(item.Key);
				}
			}
			foreach (long item2 in hashSet)
			{
				PlayerGuildCache.Remove(item2);
			}
		}

		private static void InvalidateAllGuildCaches()
		{
			PlayerGuildCache.Clear();
		}

		private static bool TryGetGuild(Player? player, out WardGuildIdentity guild)
		{
			guild = default(WardGuildIdentity);
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			long playerID = player.GetPlayerID();
			if (TryGetCachedGuild(playerID, out guild))
			{
				return true;
			}
			if (IsCachedNoGuild(playerID))
			{
				return false;
			}
			if (IsAvailable() && GetPlayerGuildByPlayerMethod != null)
			{
				try
				{
					if (TryParseGuild(GetPlayerGuildByPlayerMethod.Invoke(null, new object[1] { player }), out guild))
					{
						CacheGuildLookup(playerID, hasGuild: true, guild);
						return true;
					}
				}
				catch
				{
				}
			}
			string playerAccountId = WardOwnership.GetPlayerAccountId(player);
			string playerName = player.GetPlayerName();
			if (!string.IsNullOrWhiteSpace(playerAccountId) && !string.IsNullOrWhiteSpace(playerName) && TryGetGuildByAccountAndName(playerAccountId, playerName, out guild))
			{
				CacheGuildLookup(playerID, hasGuild: true, guild);
				return true;
			}
			CacheGuildLookup(playerID, hasGuild: false, default(WardGuildIdentity));
			return false;
		}

		private static bool TryGetGuild(long playerId, out WardGuildIdentity guild)
		{
			guild = default(WardGuildIdentity);
			if (playerId == 0L)
			{
				return false;
			}
			string playerAccountId = WardOwnership.GetPlayerAccountId(playerId);
			string playerName = WardOwnership.GetPlayerName(playerId);
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer() && TryGetSyncedGuildIdentity(playerId, playerAccountId, playerName, out guild))
			{
				CacheGuildLookup(playerId, guild.Id != 0, guild, guild.Id == 0);
				return guild.Id != 0;
			}
			if (TryGetCachedGuild(playerId, out guild))
			{
				return true;
			}
			if (IsCachedNoGuild(playerId))
			{
				return false;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null && localPlayer.GetPlayerID() == playerId)
			{
				return TryGetGuild(localPlayer, out guild);
			}
			if (!IsAvailable() || GetPlayerGuildByReferenceMethod == null || PlayerReferenceFromStringMethod == null)
			{
				return false;
			}
			if (string.IsNullOrWhiteSpace(playerAccountId))
			{
				CacheGuildLookup(playerId, hasGuild: false, default(WardGuildIdentity));
				return false;
			}
			if (string.IsNullOrWhiteSpace(playerName))
			{
				CacheGuildLookup(playerId, hasGuild: false, default(WardGuildIdentity));
				return false;
			}
			if (!string.IsNullOrWhiteSpace(playerName) && TryGetGuildByAccountAndName(playerAccountId, playerName, out guild))
			{
				CacheGuildLookup(playerId, hasGuild: true, guild);
				return true;
			}
			CacheGuildLookup(playerId, hasGuild: false, default(WardGuildIdentity));
			return false;
		}

		private static bool TryGetGuildByAccountAndName(string accountId, string playerName, out WardGuildIdentity guild)
		{
			guild = default(WardGuildIdentity);
			string accountId2 = WardOwnership.NormalizeAccountIdValue(accountId);
			string playerName2 = playerName?.Trim() ?? string.Empty;
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer() && TryGetSyncedGuildIdentity(accountId2, playerName2, out guild))
			{
				return guild.Id != 0;
			}
			if (TryResolveGuildByAccountAndNameFromApi(accountId2, playerName2, out guild))
			{
				return guild.Id != 0;
			}
			return false;
		}

		internal static bool TryResolveAuthoritativeGuildIdentity(long playerId, string accountId, string playerName, out WardGuildIdentity guild)
		{
			guild = default(WardGuildIdentity);
			if (!IsAvailable())
			{
				return false;
			}
			Player player = Player.GetPlayer(playerId);
			if ((Object)(object)player != (Object)null && TryResolveGuildByPlayerFromApi(player, out guild))
			{
				return true;
			}
			string accountId2 = WardOwnership.NormalizeAccountIdValue(accountId);
			string playerName2 = playerName?.Trim() ?? string.Empty;
			return TryResolveGuildByAccountAndNameFromApi(accountId2, playerName2, out guild);
		}

		internal static bool TryResolveCachedAuthoritativeGuildIdentity(long playerId, string accountId, string playerName, out WardGuildIdentity guild)
		{
			guild = default(WardGuildIdentity);
			if (playerId == 0L)
			{
				return false;
			}
			string accountId2 = WardOwnership.NormalizeAccountIdValue(accountId);
			string playerName2 = playerName?.Trim() ?? string.Empty;
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer() && TryGetSyncedGuildIdentity(playerId, accountId2, playerName2, out guild))
			{
				CacheGuildLookup(playerId, guild.Id != 0, guild, guild.Id == 0);
				return true;
			}
			if (TryGetCachedGuild(playerId, out guild))
			{
				return true;
			}
			if (IsCachedAuthoritativeNoGuild(playerId))
			{
				return true;
			}
			if (!TryResolveAuthoritativeGuildIdentity(playerId, accountId2, playerName2, out guild))
			{
				return false;
			}
			CacheGuildLookup(playerId, guild.Id != 0, guild, guild.Id == 0);
			return true;
		}

		private static bool TryResolveGuildByPlayerFromApi(Player player, out WardGuildIdentity guild)
		{
			guild = default(WardGuildIdentity);
			if (GetPlayerGuildByPlayerMethod == null)
			{
				return false;
			}
			try
			{
				TryParseGuild(GetPlayerGuildByPlayerMethod.Invoke(null, new object[1] { player }), out guild);
				return true;
			}
			catch
			{
				return false;
			}
		}

		private static bool TryResolveGuildByAccountAndNameFromApi(string accountId, string playerName, out WardGuildIdentity guild)
		{
			guild = default(WardGuildIdentity);
			string text = WardOwnership.NormalizeAccountIdValue(accountId);
			string text2 = playerName?.Trim() ?? string.Empty;
			if (string.IsNullOrWhiteSpace(text) || string.IsNullOrWhiteSpace(text2) || GetPlayerGuildByReferenceMethod == null || PlayerReferenceFromStringMethod == null || !IsAvailable())
			{
				return false;
			}
			GuildAccountLookupCandidates accountLookupCandidates = GuildIdentityPolicy.GetAccountLookupCandidates(text);
			WardGuildIdentity guild2;
			bool result = TryResolveGuildByReferenceId(accountLookupCandidates.PrimaryAccountId, text2, out guild2);
			if (guild2.Id != 0 || !accountLookupCandidates.HasFallback)
			{
				guild = guild2;
				return result;
			}
			if (TryResolveGuildByReferenceId(accountLookupCandidates.FallbackAccountId, text2, out var guild3))
			{
				guild = guild3;
				return true;
			}
			guild = guild2;
			return result;
		}

		private static bool TryResolveGuildByReferenceId(string accountId, string playerName, out WardGuildIdentity guild)
		{
			guild = default(WardGuildIdentity);
			try
			{
				object obj = PlayerReferenceFromStringMethod.Invoke(null, new object[1] { accountId + ":" + playerName });
				TryParseGuild(GetPlayerGuildByReferenceMethod.Invoke(null, new object[1] { obj }), out guild);
				return true;
			}
			catch
			{
				return false;
			}
		}

		private static bool TryGetGuildById(int guildId, out WardGuildIdentity guild)
		{
			guild = default(WardGuildIdentity);
			if (guildId == 0 || GetGuildByIdMethod == null || !IsAvailable())
			{
				return false;
			}
			try
			{
				return TryParseGuild(GetGuildByIdMethod.Invoke(null, new object[1] { guildId }), out guild);
			}
			catch
			{
				return false;
			}
		}

		private static bool TryGetCachedGuild(long playerId, out WardGuildIdentity guild)
		{
			guild = default(WardGuildIdentity);
			if (!PlayerGuildCache.TryGetValue(playerId, out var value))
			{
				return false;
			}
			if (value.ExpiresAtUtc <= DateTime.UtcNow)
			{
				PlayerGuildCache.Remove(playerId);
				return false;
			}
			if (!value.HasGuild || value.GuildId == 0)
			{
				return false;
			}
			guild = new WardGuildIdentity(value.GuildId, value.GuildName);
			return true;
		}

		private static bool IsCachedNoGuild(long playerId)
		{
			if (!PlayerGuildCache.TryGetValue(playerId, out var value))
			{
				return false;
			}
			if (value.ExpiresAtUtc <= DateTime.UtcNow)
			{
				PlayerGuildCache.Remove(playerId);
				return false;
			}
			return !value.HasGuild;
		}

		private static bool IsCachedAuthoritativeNoGuild(long playerId)
		{
			if (!PlayerGuildCache.TryGetValue(playerId, out var value))
			{
				return false;
			}
			if (value.ExpiresAtUtc <= DateTime.UtcNow)
			{
				PlayerGuildCache.Remove(playerId);
				return false;
			}
			if (!value.HasGuild)
			{
				return value.AuthoritativeNoGuild;
			}
			return false;
		}

		private static void CacheGuildLookup(long playerId, bool hasGuild, WardGuildIdentity guild, bool authoritativeNoGuild = false)
		{
			if (playerId != 0L)
			{
				PlayerGuildCache[playerId] = new CachedWardGuildIdentity(hasGuild && guild.Id != 0, guild.Id, guild.Name ?? string.Empty, DateTime.UtcNow + GuildLookupCacheDuration, authoritativeNoGuild && !hasGuild);
			}
		}

		private static bool TryParseGuild(object? guildObject, out WardGuildIdentity guild)
		{
			guild = default(WardGuildIdentity);
			if (guildObject == null || GuildNameField == null || GuildGeneralField == null || GuildGeneralIdField == null)
			{
				return false;
			}
			try
			{
				object value = GuildGeneralField.GetValue(guildObject);
				int num = ((value != null) ? Convert.ToInt32(GuildGeneralIdField.GetValue(value)) : 0);
				if (num == 0)
				{
					return false;
				}
				string name = (GuildNameField.GetValue(guildObject) as string) ?? string.Empty;
				guild = new WardGuildIdentity(num, name);
				return true;
			}
			catch
			{
				return false;
			}
		}

		internal static void TryPatch(Harmony harmony)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			EnsureHooksRegistered();
			if (!_saveGuildPatched && harmony != null && !(SaveGuildMethod == null))
			{
				MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(GuildsSaveGuildPatch), "Postfix", (Type[])null, (Type[])null);
				if (!(methodInfo == null))
				{
					harmony.Patch((MethodBase)SaveGuildMethod, (HarmonyMethod)null, new HarmonyMethod(methodInfo), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					_saveGuildPatched = true;
				}
			}
		}

		private static void EnsureHooksRegistered()
		{
			if (_guildHooksRegistered)
			{
				_guildHooksActive = true;
			}
			else if (!(ApiType == null))
			{
				RegisterGuildHook(RegisterOnGuildJoinedMethod, GuildJoinedDelegateType, "HandleGuildJoinedEvent");
				RegisterGuildHook(RegisterOnGuildLeftMethod, GuildLeftDelegateType, "HandleGuildLeftEvent");
				RegisterGuildHook(RegisterOnGuildCreatedMethod, GuildCreatedDelegateType, "HandleGuildCreatedEvent");
				RegisterGuildHook(RegisterOnGuildDeletedMethod, GuildDeletedDelegateType, "HandleGuildDeletedEvent");
				_guildHooksRegistered = true;
				_guildHooksActive = true;
			}
		}

		internal static void TryShutdownHooks()
		{
			_guildHooksActive = false;
			_saveGuildPatched = false;
		}

		internal static bool IsGuildHooksActive()
		{
			return _guildHooksActive;
		}

		private static void RegisterGuildHook(MethodInfo? registerMethod, Type? delegateType, string handlerName)
		{
			if (registerMethod == null || delegateType == null)
			{
				return;
			}
			try
			{
				Delegate obj = CreateGuildCallback(delegateType, handlerName);
				if ((object)obj != null)
				{
					registerMethod.Invoke(null, new object[1] { obj });
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Failed to register Guilds hook " + handlerName + ": " + ex.GetType().Name + ": " + ex.Message));
			}
		}

		private static Delegate? CreateGuildCallback(Type delegateType, string handlerName)
		{
			MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(GuildsCompat), handlerName, (Type[])null, (Type[])null);
			MethodInfo method = delegateType.GetMethod("Invoke");
			if (methodInfo == null || method == null)
			{
				return null;
			}
			ParameterInfo[] parameters = method.GetParameters();
			ParameterExpression[] array = new ParameterExpression[parameters.Length];
			Expression[] array2 = new Expression[parameters.Length];
			for (int i = 0; i < parameters.Length; i++)
			{
				array2[i] = Expression.Convert(array[i] = Expression.Parameter(parameters[i].ParameterType, parameters[i].Name), typeof(object));
			}
			MethodCallExpression body = Expression.Call(methodInfo, array2);
			return Expression.Lambda(delegateType, body, array).Compile();
		}

		private static void HandleGuildJoinedEvent(object guild, object playerReference)
		{
			if (_guildHooksActive)
			{
				if (!TryCreateCharacterIdentityFromPlayerReference(playerReference, out var identity))
				{
					RefreshAllWardGuildProjections(liveDisplayRefresh: true);
					return;
				}
				InvalidateSyncedGuildIdentity(identity);
				RefreshWardGuildProjectionForCharacter(identity, liveDisplayRefresh: true, TryParseGuild(guild, out var guild2) ? guild2.Id : 0);
			}
		}

		private static void HandleGuildLeftEvent(object guild, object playerReference)
		{
			if (_guildHooksActive)
			{
				if (!TryCreateCharacterIdentityFromPlayerReference(playerReference, out var identity))
				{
					RefreshAllWardGuildProjections(liveDisplayRefresh: true);
					return;
				}
				InvalidateSyncedGuildIdentity(identity);
				RefreshWardGuildProjectionForCharacter(identity, liveDisplayRefresh: true, TryParseGuild(guild, out var guild2) ? guild2.Id : 0);
			}
		}

		private static void HandleGuildCreatedEvent(object guild)
		{
			if (_guildHooksActive)
			{
				RefreshAllWardGuildProjections(liveDisplayRefresh: true);
			}
		}

		private static void HandleGuildDeletedEvent(object guild)
		{
			if (_guildHooksActive)
			{
				RefreshAllWardGuildProjections(liveDisplayRefresh: true);
			}
		}
	}
	internal readonly struct SyncedWardGuildIdentity
	{
		internal bool HasGuild { get; }

		internal int GuildId { get; }

		internal string GuildName { get; }

		internal string AccountId { get; }

		internal string PlayerName { get; }

		internal SyncedWardGuildIdentity(bool hasGuild, int guildId, string guildName, string accountId, string playerName)
		{
			HasGuild = hasGuild;
			GuildId = guildId;
			GuildName = guildName ?? string.Empty;
			AccountId = WardOwnership.NormalizeAccountIdValue(accountId);
			PlayerName = playerName?.Trim() ?? string.Empty;
		}
	}
	internal static class ManagedWardPlacementPreviewService
	{
		private sealed class PlacementPreviewOverlapState
		{
			internal int CandidateInstanceId;

			internal Vector3 Point;

			internal long PlayerId;

			internal int GuildId;

			internal int SpatialRevision = -1;

			internal bool BlocksPlacement;

			internal bool HasValue;
		}

		private static readonly PlacementPreviewOverlapState OverlapCache = new PlacementPreviewOverlapState();

		internal static bool ShouldShowAsInvalid(Player? player, Component? candidate, Vector3 point)
		{
			//IL_00a6: 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_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			if (!WardAccess.IsManagedWardPlacementCandidate(candidate) || (Object)(object)candidate == (Object)null)
			{
				return false;
			}
			long num = (((Object)(object)player != (Object)null) ? player.GetPlayerID() : 0);
			int num2 = (((Object)(object)player != (Object)null) ? GuildsCompat.GetPlayerGuildId(player) : 0);
			int instanceID = ((Object)candidate).GetInstanceID();
			int managedWardSpatialIndexRevision = WardAccess.GetManagedWardSpatialIndexRevision();
			if (OverlapCache.HasValue && OverlapCache.CandidateInstanceId == instanceID && OverlapCache.PlayerId == num && OverlapCache.GuildId == num2 && OverlapCache.SpatialRevision == managedWardSpatialIndexRevision && PointsMatch(OverlapCache.Point, point))
			{
				return OverlapCache.BlocksPlacement;
			}
			bool flag = WardAccess.WouldBlockManagedWardPlacement(player, candidate, point, flash: false);
			OverlapCache.CandidateInstanceId = instanceID;
			OverlapCache.Point = point;
			OverlapCache.PlayerId = num;
			OverlapCache.GuildId = num2;
			OverlapCache.SpatialRevision = managedWardSpatialIndexRevision;
			OverlapCache.BlocksPlacement = flag;
			OverlapCache.HasValue = true;
			return flag;
		}

		internal static void Invalidate()
		{
			OverlapCache.HasValue = false;
		}

		private static bool PointsMatch(Vector3 left, Vector3 right)
		{
			//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_0013: 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)
			if (Mathf.Approximately(left.x, right.x))
			{
				return Mathf.Approximately(left.z, right.z);
			}
			return false;
		}
	}
	internal static class WardAccess
	{
		internal enum AccessDecision
		{
			NoWard,
			Allowed,
			Denied
		}

		internal readonly struct AccessResult
		{
			internal AccessDecision Decision { get; }

			internal bool IsDenied => Decision == AccessDecision.Denied;

			internal AccessResult(AccessDecision decision)
			{
				Decision = decision;
			}
		}

		internal readonly struct RestrictionScope : IDisposable
		{
			private readonly bool _active;

			private readonly WardRestrictionOptions _previousRestriction;

			internal RestrictionScope(WardRestrictionOptions restriction)
			{
				_active = true;
				_previousRestriction = _restrictionScope;
				_restrictionScope = restriction;
				_restrictionScopeDepth++;
			}

			public void Dispose()
			{
				if (_active && _restrictionScopeDepth > 0)
				{
					_restrictionScopeDepth--;
					if (_restrictionScopeDepth == 0)
					{
						_restrictionScope = WardRestrictionOptions.None;
					}
					else
					{
						_restrictionScope = _previousRestriction;
					}
				}
			}
		}

		internal readonly struct ManagedWardAllowScope : IDisposable
		{
			private readonly bool _active;

			internal ManagedWardAllowScope(bool active)
			{
				_active = active;
				if (_active)
				{
					_managedWardAllowScopeDepth++;
				}
			}

			public void Dispose()
			{
				if (_active && _managedWardAllowScopeDepth > 0)
				{
					_managedWardAllowScopeDepth--;
				}
			}
		}

		private const string NoAccessMessageKey = "$piece_noaccess";

		private static readonly ManagedWardIndex AllWardIndex = new ManagedWardIndex((PrivateArea area) => IsTrackableManagedWard(area, requireEnabled: false));

		private static readonly ManagedWardIndex EnabledWardIndex = new ManagedWardIndex((PrivateArea area) => IsTrackableManagedWard(area, requireEnabled: true));

		private static readonly List<PrivateArea> SpatialQueryBuffer = new List<PrivateArea>();

		[ThreadStatic]
		private static int _restrictionScopeDepth;

		[ThreadStatic]
		private static WardRestrictionOptions _restrictionScope;

		[ThreadStatic]
		private static int _managedWardAllowScopeDepth;

		private static bool _wardCacheInitialized;

		private static bool _managedWardSpatialIndexRequiresFullRebuild = true;

		private static float _managedWardSpatialIndexMaxRadius = -1f;

		private static int _managedWardSpatialIndexRevision;

		internal static bool IsManagedWardAllowScopeActive => _managedWardAllowScopeDepth > 0;

		internal static RestrictionScope EnterRestrictionScope(WardRestrictionOptions restriction)
		{
			return new RestrictionScope(restriction);
		}

		internal static ManagedWardAllowScope EnterManagedWardAllowScope()
		{
			return new ManagedWardAllowScope(active: true);
		}

		internal static bool TryGetRestrictionScope(out WardRestrictionOptions restriction)
		{
			restriction = _restrictionScope;
			if (_restrictionScopeDepth > 0)
			{
				return restriction != WardRestrictionOptions.None;
			}
			return false;
		}

		internal static void RegisterManagedWard(ManagedWardRef ward)
		{
			RefreshManagedWardState(ward);
		}

		internal static void RefreshManagedWardState(ManagedWardRef ward)
		{
			PrivateArea area = ward.Area;
			if ((Object)(object)area == (Object)null)
			{
				return;
			}
			EnsureManagedWardCacheInitialized();
			if (!IsTrackableManagedWard(ward, requireEnabled: false))
			{
				UnregisterManagedWard(ward);
				return;
			}
			int instanceID = ((Object)area).GetInstanceID();
			bool flag = false;
			bool flag2 = false;
			if (AllWardIndex.Add(area))
			{
				flag = true;
			}
			if (area.IsEnabled())
			{
				if (EnabledWardIndex.Add(area))
				{
					flag2 = true;
				}
			}
			else if (EnabledWardIndex.Remove(area))
			{
				ManagedWardRuntimeContexts.ResetPresenceState(area);
				flag2 = true;
			}
			if (flag || flag2)
			{
				UpdateManagedWardSpatialIndexMembership(area, instanceID, flag, flag2);
			}
			if (flag2)
			{
				ManagedWardPresenceService.Invalidate();
				ManagedWardPlacementPreviewService.Invalidate();
			}
		}

		internal static void UnregisterManagedWard(PrivateArea? area)
		{
			UnregisterManagedWard(ManagedWardRef.FromArea(area));
		}

		internal static void UnregisterManagedWard(ManagedWardRef ward)
		{
			PrivateArea area = ward.Area;
			if (!((Object)(object)area == (Object)null))
			{
				int instanceID = ((Object)area).GetInstanceID();
				bool flag = false;
				bool flag2 = false;
				if (AllWardIndex.Remove(area))
				{
					flag = true;
				}
				if (EnabledWardIndex.Remove(area))
				{
					flag2 = true;
				}
				ManagedWardRuntimeContexts.ResetPresenceState(area);
				if (flag || flag2)
				{
					UpdateManagedWardSpatialIndexMembership(area, instanceID, flag, flag2);
				}
				if (flag2)
				{
					ManagedWardPresenceService.Invalidate();
					ManagedWardPlacementPreviewService.Invalidate();
				}
			}
		}

		internal static bool HasEnabledManagedWards()
		{
			EnsureManagedWardCacheInitialized();
			return EnabledWardIndex.Count > 0;
		}

		internal static void RefreshManagedWardSpatialIndexEntry(ManagedWardRef ward)
		{
			PrivateArea area = ward.Area;
			if ((Object)(object)area == (Object)null)
			{
				return;
			}
			EnsureManagedWardCacheInitialized();
			if (_managedWardSpatialIndexRequiresFullRebuild || !Mathf.Approximately(_managedWardSpatialIndexMaxRadius, WardSettings.MaxRadius))
			{
				if (!_managedWardSpatialIndexRequiresFullRebuild)
				{
					_managedWardSpatialIndexRequiresFullRebuild = true;
					BumpManagedWardSpatialRevision();
				}
				ManagedWardPlacementPreviewService.Invalidate();
				return;
			}
			int instanceID = ((Object)area).GetInstanceID();
			bool flag = AllWardIndex.Contains(instanceID);
			bool flag2 = EnabledWardIndex.Contains(instanceID);
			if (flag || flag2)
			{
				UpdateManagedWardSpatialIndexMembership(area, instanceID, flag, flag2);
			}
		}

		internal static void ResetManagedWardCache()
		{
			AllWardIndex.Clear();
			EnabledWardIndex.Clear();
			SpatialQueryBuffer.Clear();
			ManagedWardPresenceService.ResetRuntimeState();
			_wardCacheInitialized = false;
			_managedWardSpatialIndexRequiresFullRebuild = true;
			_managedWardSpatialIndexMaxRadius = -1f;
			_managedWardSpatialIndexRevision = 0;
			ManagedWardPlacementPreviewService.Invalidate();
		}

		internal static bool CheckAccess(Vector3 point, float radius, long playerId, bool flash = true, bool wardCheck = false)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return !EvaluateAccess(point, radius, playerId, flash, wardCheck).IsDenied;
		}

		internal static AccessResult EvaluateAccess(Vector3 point, float radius, long playerId, bool flash = true, bool wardCheck = false)
		{
			//IL_0000: 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)
			IReadOnlyList<PrivateArea> candidateManagedWards = GetCandidateManagedWards(point, radius, requireEnabled: true);
			return EvaluateAccessAgainstCandidates(point, radius, playerId, candidateManagedWards, flash, wardCheck);
		}

		internal static AccessResult EvaluateAccessAgainstCandidates(Vector3 point, float radius, long playerId, IReadOnlyList<PrivateArea> areas, bool flash = true, bool wardCheck = false)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return EvaluateAccessAgainstCandidates(point, radius, playerId, areas, null, flash, wardCheck);
		}

		internal static bool CheckRestrictionAccess(WardRestrictionOptions restriction, Vector3 point, float radius, long playerId, bool flash = true, bool wardCheck = false)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return !EvaluateRestrictionAccess(restriction, point, radius, playerId, flash, wardCheck).IsDenied;
		}

		internal static AccessResult EvaluateRestrictionAccess(WardRestrictionOptions restriction, Vector3 point, float radius, long playerId, bool flash = true, bool wardCheck = false)
		{
			//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)
			IReadOnlyList<PrivateArea> candidateManagedWards = GetCandidateManagedWards(point, radius, requireEnabled: true);
			return EvaluateRestrictionAccessAgainstCandidates(restriction, point, radius, playerId, candidateManagedWards, flash, wardCheck);
		}

		internal static AccessResult EvaluateRestrictionAccessAgainstCandidates(WardRestrictionOptions restriction, Vector3 point, float radius, long playerId, IReadOnlyList<PrivateArea> areas, bool flash = true, bool wardCheck = false)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return EvaluateAccessAgainstCandidates(point, radius, playerId, areas, restriction, flash, wardCheck);
		}

		private static AccessResult EvaluateAccessAgainstCandidates(Vector3 point, float radius, long playerId, IReadOnlyList<PrivateArea> areas, WardRestrictionOptions? restriction, bool flash, bool wardCheck)
		{
			//IL_0045: 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)
			if (areas.Count == 0)
			{
				return new AccessResult(AccessDecision.NoWard);
			}
			ManagedWardAccessActor actor;
			bool flag = ManagedWardAccessEvaluator.TryCreateActorForAccessCheck(playerId, out actor);
			bool flag2 = false;
			bool flag3 = false;
			PrivateArea val = null;
			float num = float.MaxValue;
			foreach (PrivateArea area in areas)
			{
				if ((Object)(object)area == (Object)null || !area.IsInside(point, radius))
				{
					continue;
				}
				flag2 = true;
				if ((restriction.HasValue && !WardSettings.HasRestriction(WardSettings.GetConfiguration(area), restriction.Value)) || (flag && ManagedWardAccessEvaluator.HasPlayerAccess(area, actor)))
				{
					continue;
				}
				flag3 = true;
				if (flash)
				{
					float num2 = Utils.DistanceXZ(((Component)area).transform.position, point);
					if (num2 < num)
					{
						num = num2;
						val = area;
					}
				}
				if (wardCheck && !flash)
				{
					break;
				}
			}
			if (!flag2)
			{
				return new AccessResult(AccessDecision.NoWard);
			}
			if (!flag3)
			{
				return new AccessResult(AccessDecision.Allowed);
			}
			if (val != null)
			{
				val.FlashShield(false);
			}
			return new AccessResult(AccessDecision.Denied);
		}

		internal static int CollectDeniedManagedWardCandidates(long playerId, IReadOnlyList<PrivateArea> areas, WardRestrictionOptions restriction, List<PrivateArea> deniedAreas)
		{
			deniedAreas.Clear();
			if (playerId == 0L || areas.Count == 0)
			{
				return 0;
			}
			ManagedWardAccessActor actor = ManagedWardAccessEvaluator.CreateActor(playerId);
			foreach (PrivateArea area in areas)
			{
				if (!((Object)(object)area == (Object)null) && WardSettings.HasRestriction(WardSettings.GetConfiguration(area), restriction) && !ManagedWardAccessEvaluator.HasPlayerAccess(area, actor))
				{
					deniedAreas.Add(area);
				}
			}
			return deniedAreas.Count;
		}

		internal static bool IsInsideAnyManagedWard(Vector3 point, float radius, IReadOnlyList<PrivateArea> areas)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < areas.Count; i++)
			{
				PrivateArea val = areas[i];
				if ((Object)(object)val != (Object)null && val.IsInside(point, radius))
				{
					return true;
				}
			}
			return false;
		}

		internal static bool TryBlockInteraction(Component target, Player? player, ref bool result)
		{
			if (!ShouldBlock(target, player, 0f))
			{
				return true;
			}
			ShowNoAccessMessage(player);
			result = true;
			return false;
		}

		internal static bool TryBlockInteraction(WardRestrictionOptions restriction, Component target, Player? player, ref bool result)
		{
			if (!ShouldBlockRestriction(restriction, target, player, 0f))
			{
				return true;
			}
			ShowNoAccessMessage(player);
			result = true;
			return false;
		}

		internal static bool TryBlockAction(Component target, Player? player, ref bool result)
		{
			if (!ShouldBlock(target, player, 0f))
			{
				return true;
			}
			ShowNoAccessMessage(player);
			result = false;
			return false;
		}

		internal static bool TryBlockVoid(WardRestrictionOptions restriction, Component target, Player? player)
		{
			if (!ShouldBlockRestriction(restriction, target, player, 0f))
			{
				return true;
			}
			ShowNoAccessMessage(player);
			return false;
		}

		internal static bool TryBlockPlacement(Player? player, Vector3 point, float radius)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			if (!ShouldBlock(point, radius, player))
			{
				return true;
			}
			ShowNoAccessMessage(player);
			return false;
		}

		internal static bool TryBlockItemUse(Player? player, ItemData? item, ref bool result)
		{
			if (!ShouldBlockConfiguredItemUse(player, item))
			{
				return true;
			}
			ShowBlockedItemMessage(player);
			result = false;
			return false;
		}

		internal static bool TryBlockItemUse(Player? player, ItemData? item)
		{
			if (!ShouldBlockConfiguredItemUse(player, item))
			{
				return true;
			}
			ShowBlockedItemMessage(player);
			return false;
		}

		internal static bool TryBlockItemUse(Player? player, ItemData? item, Vector3 targetPoint)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			if (!ShouldBlockConfiguredItemUse(player, item, targetPoint))
			{
				return true;
			}
			ShowBlockedItemMessage(player);
			return false;
		}

		internal static bool TryBlockItemUseAtPlayerOrHoveredTamedCreature(Player? player, ItemData? item)
		{
			if (!ShouldBlockConfiguredItemUse(player, item) && !ShouldBlockConfiguredItemUseAgainstHoveredTamedCreature(player, item))
			{
				return true;
			}
			ShowBlockedItemMessage(player);
			return false;
		}

		internal static bool TryForceUnequipBlockedItems(Player? player)
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null || (Object)(object)player != (Object)(object)Player.m_localPlayer)
			{
				return false;
			}
			if (!HasEnabledManagedWards())
			{
				return false;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory == null)
			{
				return false;
			}
			List<ItemData> inventory2 = inventory.m_inventory;
			if (inventory2 == null || inventory2.Count == 0)
			{
				return false;
			}
			bool flag = false;
			for (int i = 0; i < inventory2.Count; i++)
			{
				ItemData val = inventory2[i];
				if (val != null && val.m_equipped && IsConfiguredBlockedItem(val))
				{
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				return false;
			}
			if (!ShouldBlock(((Component)player).transform.position, 0f, player, flash: false))
			{
				return false;
			}
			bool flag2 = false;
			for (int j = 0; j < inventory2.Count; j++)
			{
				ItemData val2 = inventory2[j];
				if (val2 != null && val2.m_equipped && IsConfiguredBlockedItem(val2))
				{
					((Humanoid)player).UnequipItem(val2, false);
					flag2 = true;
				}
			}
			if (flag2)
			{
				ShowBlockedItemMessage(player);
			}
			return flag2;
		}

		internal static bool TryBlockAttack(Player? player, ref bool result)
		{
			return TryBlockAttack(player, (player != null) ? ((Humanoid)player).GetCurrentWeapon() : null, ref result);
		}

		internal static bool TryBlockAttack(Player? player, ItemData? item, ref bool result)
		{
			if (!ShouldBlockConfiguredItemUse(player, item) && !ShouldBlockConfiguredItemUseAgainstHoveredTamedCreature(player, item))
			{
				return true;
			}
			if (!TryForceUnequipBlockedItems(player))
			{
				ShowBlockedItemMessage(player);
			}
			result = false;
			return false;
		}

		internal static bool ShouldBlock(Component? target, Player? player, float radius, bool flash = true)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)target == (Object)null)
			{
				return false;
			}
			return ShouldBlock(target.transform.position, radius, player, flash);
		}

		internal static bool ShouldBlock(Vector3 point, float radius, Player? player, bool flash = true)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			if (!HasEnabledManagedWards())
			{
				return false;
			}
			return EvaluateAccess(point, radius, player.GetPlayerID(), flash).IsDenied;
		}

		internal static bool ShouldBlockRestriction(WardRestrictionOptions restriction, Component? target, Player? player, float radius, bool flash = true)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)target == (Object)null)
			{
				return false;
			}
			return ShouldBlockRestriction(restriction, target.transform.position, radius, player, flash);
		}

		internal static bool ShouldBlockRestriction(WardRestrictionOptions restriction, Vector3 point, float radius, Player? player, bool flash = true)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			if (!HasEnabledManagedWards())
			{
				return false;
			}
			return EvaluateRestrictionAccess(restriction, point, radius, player.GetPlayerID(), flash).IsDenied;
		}

		internal static bool ShouldBlockPickup(GameObject? go, Player? player)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)go == (Object)null || !WardItemPrefabPolicy.CanAnyPickupBeBlocked())
			{
				return false;
			}
			if (IsPlacedConsumable(go.GetComponent<ItemDrop>()))
			{
				return false;
			}
			if (WardItemPrefabPolicy.ShouldBlockPickup(go))
			{
				return ShouldBlockRestriction(WardRestrictionOptions.Pickup, go.transform.position, 0f, player);
			}
			return false;
		}

		internal static bool ShouldBlockPickup(ItemDrop? itemDrop, Player? player)
		{
			if ((Object)(object)itemDrop == (Object)null || !WardItemPrefabPolicy.CanAnyPickupBeBlocked())
			{
				return false;
			}
			if (!IsPlacedConsumable(itemDrop) && WardItemPrefabPolicy.ShouldBlockPickup(itemDrop))
			{
				return ShouldBlockRestriction(WardRestrictionOptions.Pickup, (Component?)(object)itemDrop, player, 0f);
			}
			return false;
		}

		internal static bool IsPlacedConsumable(ItemDrop? itemDrop)
		{
			//IL_0031: 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_0044: Invalid comparison between Unknown and I4
			if ((Object)(object)itemDrop != (Object)null && itemDrop.IsPiece())
			{
				ItemData itemData = itemDrop.m_itemData;
				if (itemData == null)
				{
					return false;
				}
				return (int)(itemData.m_shared?.m_itemType).GetValueOrDefault() == 2;
			}
			return false;
		}

		internal static void ShowNoAccessMessage(Player? player)
		{
			if (!((Object)(object)player == (Object)null) && !((Object)(object)player != (Object)(object)Player.m_localPlayer))
			{
				((Character)player).Message((MessageType)2, "$piece_noaccess", 0, (Sprite)null);
			}
		}

		internal static void ShowBlockedItemMessage(Player? player)
		{
			if (!((Object)(object)player == (Object)null) && !((Object)(object)player != (Object)(object)Player.m_localPlayer))
			{
				((Character)player).Message((MessageType)2, WardLocalization.Localize("$stuw_msg_blocked_item", "A ward prevents using this item here."), 0, (Sprite)null);
			}
		}

		internal static void ShowProtectedBuildingDamageMessage(Player? player)
		{
			if (!((Object)(object)player == (Object)null) && !((Object)(object)player != (Object)(object)Player.m_localPlayer))
			{
				((Character)player).Message((MessageType)2, WardLocalization.Localize("$stuw_msg_building_damage_protected", "An active Ward prevents damaging protected structures."), 0, (Sprite)null);
			}
		}

		internal static void ShowWardOverlapMessage(Player? player)
		{
			if (!((Object)(object)player == (Object)null) && !((Object)(object)player != (Object)(object)Player.m_localPlayer))
			{
				((Character)player).Message((MessageType)2, WardLocalization.Localize("$stuw_msg_overlap", "Another Ward is too close."), 0, (Sprite)null);
			}
		}

		internal static void ShowWardLimitMessage(Player? player, int limit)
		{
			if (!((Object)(object)player == (Object)null) && !((Object)(object)player != (Object)(object)Player.m_localPlayer))
			{
				string text = WardLocalization.LocalizeFormat("$stuw_msg_limit_with_max", "Ward limit reached (max {0})", limit);
				((Character)player).Message((MessageType)2, text, 0, (Sprite)null);
			}
		}

		internal static Player? GetPlayer(Humanoid? humanoid)
		{
			return (Player?)(object)((humanoid is Player) ? humanoid : null);
		}

		internal static Player? GetPlayer(Collider? collider)
		{
			if ((Object)(object)collider == (Object)null)
			{
				return null;
			}
			return ((Component)collider).GetComponentInParent<Player>();
		}

		internal static float GetTerrainRadius(GameObject? prefab)
		{
			if ((Object)(object)prefab == (Object)null)
			{
				return 0f;
			}
			TerrainModifier component = prefab.GetComponent<TerrainModifier>();
			if ((Object)(object)component != (Object)null)
			{
				return component.GetRadius();
			}
			TerrainOp component2 = prefab.GetComponent<TerrainOp>();
			if (!((Object)(object)component2 != (Object)null))
			{
				return 0f;
			}
			return component2.GetRadius();
		}

		internal static bool IsManagedWard(PrivateArea? area, bool requireEnabled)
		{
			return IsManagedWard(ManagedWardRef.FromArea(area), requireEnabled);
		}

		internal static bool IsManagedWard(ManagedWardRef ward, bool requireEnabled)
		{
			return IsTrackableManagedWard(ward, requireEnabled);
		}

		internal static bool CanConfigureWard(PrivateArea? area, Player? player)
		{
			return CanConfigureWard(ManagedWardRef.FromArea(area), player);
		}

		internal static bool CanConfigureWard(ManagedWardRef ward, Player? player)
		{
			if ((Object)(object)ward.Area == (Object)null || (Object)(object)player == (Object)null || (Object)(object)player != (Object)(object)Player.m_localPlayer || !IsManagedWard(ward, requireEnabled: false))
			{
				return false;
			}
			return HasManagedWardTrust(ward, player.GetPlayerID());
		}

		internal static bool HasManagedWardTrust(PrivateArea? area, long playerId)
		{
			return HasManagedWardTrust(ManagedWardRef.FromArea(area), playerId);
		}

		internal static bool HasManagedWardTrust(ManagedWardRef ward, long playerId)
		{
			if ((Object)(object)ward.Area == (Object)null || playerId == 0L || !IsManagedWard(ward, requireEnabled: false))
			{
				return false;
			}
			return ManagedWardAccessEvaluator.HasPlayerAccess(ward.Area, ManagedWardAccessEvaluator.CreateActor(playerId));
		}

		internal static bool HasManagedWardTrust(ZDO? zdo, long playerId)
		{
			if (zdo != null && zdo.IsValid() && playerId != 0L && WardOwnership.IsManagedWardZdo(zdo))
			{
				return ManagedWardAccessEvaluator.HasPlayerAccess(zdo, ManagedWardAccessEvaluator.CreateActor(playerId));
			}
			return false;
		}

		internal static bool IsDirectWardOwner(ManagedWardRef ward, long playerId)
		{
			if ((Object)(object)ward.Area == (Object)null || playerId == 0L || !IsManagedWard(ward, requireEnabled: false))
			{
				return false;
			}
			return GetCanonicalCreatorPlayerId(ward.Area) == playerId;
		}

		internal static bool ShouldBlockHostileCreatureDamageToBuilding(Vector3 point)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return ManagedWardPresenceService.ShouldBlockHostileCreatureDamageToBuilding(point);
		}

		internal static bool TryBlockManagedWardPlacement(Player? player, Component? candidate, Vector3 point, ref bool result)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			if (!IsManagedWardPlacementCandidate(candidate))
			{
				return true;
			}
			if (!WouldBlockManagedWardPlacement(player, candidate, point, flash: true))
			{
				return true;
			}
			ShowWardOverlapMessage(player);
			result = false;
			return false;
		}

		internal static bool TryBlockManagedWardPlacement(Player? player, Component? candidate, Vector3 point)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			if (!IsManagedWardPlacementCandidate(candidate))
			{
				return true;
			}
			if (!WouldBlockManagedWardPlacement(player, candidate, point, flash: true))
			{
				return true;
			}
			ShowWardOverlapMessage(player);
			return false;
		}

		internal static float GetMaxNonOverlappingRadius(PrivateArea? area, float fallbackRadius)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			long canonicalCreatorPlayerId = GetCanonicalCreatorPlayerId(area);
			int guildId = (GuildsCompat.IsAvailable() ? GuildsCompat.GetWardGuildId(area) : 0);
			if (!((Object)(object)area == (Object)null))
			{
				return GetMaxNonOverlappingRadius(((Component)area).transform.position, canonicalCreatorPlayerId, guildId, area, fallbackRadius);
			}
			return fallbackRadius;
		}

		internal static float GetMaxNonOverlappingRadius(Vector3 point, long ownerCreatorPlayerId, int guildId, PrivateArea? ignoredWard, float fallbackRadius)
		{
			//IL_0000: 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)
			IReadOnlyList<PrivateArea> candidateManagedWards = GetCandidateManagedWards(point, fallbackRadius, requireEnabled: false);
			if (candidateManagedWards.Count == 0)
			{
				return fallbackRadius;
			}
			return WardOverlapPolicy.GetMaxNonOverlappingRadius(fallbackRadius, CreateWardOverlapQuery(point, fallbackRadius, ownerCreatorPlayerId, guildId, ignoredWard), BuildWardOverlapAreas(candidateManagedWards, guildId));
		}

		internal static bool TryGetAutomaticPlacementRadius(Player? player, Vector3 point, out float radius)
		{
			//IL_0020: 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 ((Object)(object)player == (Object)null)
			{
				radius = 8f;
				return false;
			}
			long playerID = player.GetPlayerID();
			int playerGuildId = GuildsCompat.GetPlayerGuildId(player);
			IReadOnlyList<PrivateArea> candidateManagedWards = GetCandidateManagedWards(point, WardSettings.MaxRadius, requireEnabled: false);
			return WardOverlapPolicy.TryGetPlacementRadius(8f, WardSettings.MaxRadius, CreateWardOverlapQuery(point, WardSettings.MaxRadius, playerID, playerGuildId, null), BuildWardOverlapAreas(candidateManagedWards, playerGuildId), out radius);
		}

		internal static long GetCanonicalCreatorPlayerId(PrivateArea? area)
		{
			long creatorPlayerId = ManagedWardRef.FromArea(area).CreatorPlayerId;
			if (creatorPlayerId != 0L)
			{
				return creatorPlayerId;
			}
			Piece val = (((Object)(object)area?.m_piece != (Object)null) ? area.m_piece : ((area != null) ? ((Component)area).GetComponent<Piece>() : null));
			if (!((Object)(object)val != (Object)null))
			{
				return 0L;
			}
			return val.GetCreator();
		}

		internal static PrivateArea? FindNearestManagedWard(Vector3 point, float radius = 0f, bool requireEnabled = true, Predicate<PrivateArea>? predicate = null)
		{
			//IL_0014: 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_0050: 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)
			IReadOnlyList<PrivateArea> readOnlyList;
			if (predicate == null)
			{
				readOnlyList = GetCandidateManagedWards(point, radius, requireEnabled);
			}
			else
			{
				List<PrivateArea> list = new List<PrivateArea>();
				FillCandidateManagedWards(point, radius, requireEnabled, list);
				readOnlyList = list;
			}
			if (readOnlyList.Count == 0)
			{
				return null;
			}
			PrivateArea result = null;
			float num = float.MaxValue;
			foreach (PrivateArea item in readOnlyList)
			{
				if (!((Object)(object)item == (Object)null) && item.IsInside(point, radius) && (predicate == null || predicate(item)))
				{
					float num2 = Utils.DistanceXZ(((Component)item).transform.position, point);
					if (!(num2 >= num))
					{
						num = num2;
						result = item;
					}
				}
			}
			return result;
		}

		private static bool ShouldBlockConfiguredItemUse(Player? player, ItemData? item)
		{
			return ShouldBlockConfiguredItemUse(player, item, null);
		}

		private static bool ShouldBlockConfiguredItemUse(Player? player, ItemData? item, Vector3? targetPoint)
		{
			//IL_0027: 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)player == (Object)null || item == null)
			{
				return false;
			}
			if (!HasEnabledManagedWards())
			{
				return false;
			}
			if (!IsConfiguredBlockedItem(item))
			{
				return false;
			}
			if (ShouldBlock(((Component)player).transform.position, 0f, player))
			{
				return true;
			}
			if (targetPoint.HasValue)
			{
				return ShouldBlock(targetPoint.Value, 0f, player);
			}
			return false;
		}

		private static bool ShouldBlockConfiguredItemUseAgainstHoveredTamedCreature(Player? player, ItemData? item)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null || item == null || !HasEnabledManagedWards() || !IsConfiguredBlockedItem(item))
			{
				return false;
			}
			if (TryGetHoveredTamedCreaturePoint(player, out var targetPoint))
			{
				return ShouldBlockConfiguredItemUse(player, item, targetPoint);
			}
			return false;
		}

		private static bool IsConfiguredBlockedItem(ItemData? item)
		{
			if (item == null)
			{
				return false;
			}
			return WardItemPrefabPolicy.IsBlockedItem(item);
		}

		private static bool TryGetHoveredTamedCreaturePoint(Player? player, out Vector3 targetPoint)
		{
			//IL_0001: 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_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)
			targetPoint = default(Vector3);
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			Character hoveringCreature = player.m_hoveringCreature;
			if ((Object)(object)hoveringCreature != (Object)null && hoveringCreature.IsTamed())
			{
				targetPoint = ((Component)hoveringCreature).transform.position;
				return true;
			}
			try
			{
				Character val = null;
				GameObject val2 = null;
				player.FindHoverObject(ref val2, ref val);
				if ((Object)(object)val == (Object)null || !val.IsTamed())
				{
					return false;
				}
				targetPoint = ((Component)val).transform.position;
				return true;
			}
			catch
			{
				return false;
			}
		}

		internal static bool WouldBlockManagedWardPlacement(Player? player, Component? candidate, Vector3 point, bool flash)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			if (!StuWardArea.IsManaged(((Object)(object)candidate != (Object)null) ? (candidate.GetComponent<PrivateArea>() ?? candidate.GetComponentInParent<PrivateArea>()) : null))
			{
				return false;
			}
			float radius = 8f;
			return OverlapsForeignManagedWard(point, radius, player.GetPlayerID(), GuildsCompat.GetPlayerGuildId(player), null, flash);
		}

		private static bool OverlapsForeignManagedWard(Vector3 point, float radius, long ownerCreatorPlayerId, int guildId, PrivateArea? ignoredWard, bool flash)
		{
			//IL_0000: 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_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			IReadOnlyList<PrivateArea> candidateManagedWards = GetCandidateManagedWards(point, radius, requireEnabled: false);
			if (candidateManagedWards.Count == 0)
			{
				return false;
			}
			bool result = false;
			PrivateArea val = null;
			float num = float.MaxValue;
			WardOverlapQuery query = CreateWardOverlapQuery(point, radius, ownerCreatorPlayerId, guildId, ignoredWard);
			foreach (PrivateArea item in candidateManagedWards)
			{
				if ((Object)(object)item == (Object)null || (Object)(object)item == (Object)(object)ignoredWard)
				{
					continue;
				}
				WardOverlapArea area = CreateWardOverlapArea(item, guildId);
				if (!WardOverlapPolicy.IsForeignOverlap(query, area))
				{
					continue;
				}
				result = true;
				if (flash)
				{
					float num2 = Utils.DistanceXZ(((Component)item).transform.position, point);
					if (num2 < num)
					{
						num = num2;
						val = item;
					}
				}
			}
			if ((Object)(object)val != (Object)null)
			{
				WardSettings.HighlightPlacementBlockingWard(val);
				ZNetView nView = WardPrivateAreaSafeAccess.GetNView(val);
				if ((Object)(object)nView != (Object)null && nView.IsValid())
				{
					val.FlashShield(false);
				}
			}
			return result;
		}

		private static WardOverlapQuery CreateWardOverlapQuery(Vector3 point, float radius, long ownerCreatorPlayerId, int guildId, PrivateArea? ignoredWard)
		{
			//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)
			return new WardOverlapQuery(point.x, point.z, radius, ownerCreatorPlayerId, guildId, ((Object)(object)ignoredWard != (Object)null) ? ((Object)ignoredWard).GetInstanceID() : 0);
		}

		private static List<WardOverlapArea> BuildWardOverlapAreas(IReadOnlyList<PrivateArea> areas, int queryGuildId)
		{
			List<WardOverlapArea> list = new List<WardOverlapArea>(areas.Count);
			for (int i = 0; i < areas.Count; i++)
			{
				PrivateArea val = areas[i];
				if ((Object)(object)val != (Object)null)
				{
					list.Add(CreateWardOverlapArea(val, queryGuildId));
				}
			}
			return list;
		}

		private static WardOverlapArea CreateWardOverlapArea(PrivateArea area, int queryGuildId)
		{
			//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_0018: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)area).transform.position;
			return new WardOverlapArea(((Object)area).GetInstanceID(), position.x, position.z, WardSettings.GetStoredRadiusOrMin(area), GetCanonicalCreatorPlayerId(area), (queryGuildId != 0 && GuildsCompat.IsAvailable()) ? GuildsCompat.GetWardGuildId(area) : 0);
		}

		internal static int GetManagedWardSpatialIndexRevision()
		{
			return _managedWardSpatialIndexRevision;
		}

		internal static bool IsManagedWardPlacementCandidate(Component? candidate)
		{
			return StuWardArea.IsManaged(((Object)(object)candidate != (Object)null) ? (candidate.GetComponent<PrivateArea>() ?? candidate.GetComponentInParent<PrivateArea>()) : null);
		}

		private static void EnsureManagedWardCacheInitialized()
		{
			if (_wardCacheInitialized)
			{
				return;
			}
			_wardCacheInitialized = true;
			AllWardIndex.Clear();
			EnabledWardIndex.Clear();
			List<PrivateArea> allAreas = PrivateArea.m_allAreas;
			if (allAreas == null)
			{
				return;
			}
			for (int i = 0; i < allAreas.Count; i++)
			{
				PrivateArea val = allAreas[i];
				if (IsTrackableManagedWard(val, requireEnabled: false))
				{
					AllWardIndex.Add(val);
					if (val.IsEnabled())
					{
						EnabledWardIndex.Add(val);
					}
				}
			}
			_managedWardSpatialIndexRequiresFullRebuild = true;
		}

		private static bool IsTrackableManagedWard(PrivateArea? area, bool requireEnabled)
		{
			return IsTrackableManagedWard(ManagedWardRef.FromArea(area), requireEnabled);
		}

		private static bool IsTrackableManagedWard(ManagedWardRef ward, bool requireEnabled)
		{
			PrivateArea area = ward.Area;
			if ((Object)(object)area == (Object)null || ward.IsPlacementGhost || !ManagedWardIdentity.EnsureManagedComponent(ward))
			{
				return false;
			}
			if (requireEnabled && !area.IsEnabled())
			{
				return false;
			}
			return ward.HasValidNetworkIdentity;
		}

		internal static IReadOnlyList<PrivateArea> GetCandidateManagedWards(Vector3 point, float radius, bool requireEnabled)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			FillCandidateManagedWards(point, radius, requireEnabled, SpatialQueryBuffer);
			return SpatialQueryBuffer;
		}

		internal static void FillCandidateManagedWards(Vector3 point, float radius, bool requireEnabled, List<PrivateArea> destination)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			EnsureManagedWardSpatialIndexInitialized();
			(requireEnabled ? EnabledWardIndex : AllWardIndex).FillCandidates(point, radius, destination);
		}

		private static void EnsureManagedWardSpatialIndexInitialized()
		{
			EnsureManagedWardCacheInitialized();
			float maxRadius = WardSettings.MaxRadius;
			if (_managedWardSpatialIndexRequiresFullRebuild || !Mathf.Approximately(_managedWardSpatialIndexMaxRadius, maxRadius))
			{
				AllWardIndex.ClearSpatialIndex();
				EnabledWardIndex.ClearSpatialIndex();
				SpatialQueryBuffer.Clear();
				AllWardIndex.RebuildSpatialIndex();
				EnabledWardIndex.RebuildSpatialIndex();
				_managedWardSpatialIndexRequiresFullRebuild = false;
				_managedWardSpatialIndexMaxRadius = maxRadius;
			}
		}

		private static void UpdateManagedWardSpatialIndexMembership(PrivateArea area, int instanceId, bool updateAllWardIndex, bool updateEnabledWardIndex)
		{
			EnsureManagedWardCacheInitialized();
			if (_managedWardSpatialIndexRequiresFullRebuild || !Mathf.Approximately(_managedWardSpatialIndexMaxRadius, WardSettings.MaxRadius))
			{
				if (!_managedWardSpatialIndexRequiresFullRebuild)
				{
					_managedWardSpatialIndexRequiresFullRebuild = true;
					if (updateAllWardIndex)
					{
						BumpManagedWardSpatialRevision();
					}
				}
				if (updateAllWardIndex)
				{
					ManagedWardPlacementPreviewService.Invalidate();
				}
			}
			else
			{
				if (updateAllWardIndex)
				{
					AllWardIndex.UpdateSpatialIndex(area, instanceId, AllWardIndex.Contains(instanceId));
					BumpManagedWardSpatialRevision();
					ManagedWardPlacementPreviewService.Invalidate();
				}
				if (updateEnabledWardIndex)
				{
					EnabledWardIndex.UpdateSpatialIndex(area, instanceId, EnabledWardIndex.Contains(instanceId));
				}
			}
		}

		private static void BumpManagedWardSpatialRevision()
		{
			_managedWardSpatialIndexRevision = ((_managedWardSpatialIndexRevision == int.MaxValue) ? 1 : (_managedWardSpatialIndexRevision + 1));
		}
	}
	internal sealed class WardGuiController : MonoBehaviour
	{
		private sealed class PermittedRowView
		{
			internal GameObject Root { get; }

			internal Text NameText { get; }

			internal Text StatusText { get; }

			internal string SearchText { get; set; } = string.Empty;

			internal int LastSeenGeneration { get; set; }

			internal PermittedRowView(GameObject root, Text nameText, Text statusText)
			{
				Root = root;
				NameText = nameText;
				StatusText = statusText;
			}
		}

		private sealed class RecentPlayerRowView
		{
			internal GameObject Root { get; }

			internal Text NameText { get; }

			internal Text StatusText { get; }

			internal Button AddButton { get; }

			internal string SearchText { get; set; } = string.Empty;

			internal int LastSeenGeneration { get; set; }

			internal RecentPlayerRowView(GameObject root, Text nameText, Text statusText, Button addButton)
			{
				Root = root;
				NameText = nameText;
				StatusText = statusText;
				AddButton = addButton;
			}
		}

		private sealed class StatusRowView
		{
			internal GameObject Root { get; }

			internal Text Text { get; }

			internal StatusRowView(GameObject root, Text text)
			{
				Root = root;
				Text = text;
			}
		}

		private enum WardSettingsPage
		{
			General,
			Restrictions
		}

		private enum RecentPlayersListState
		{
			None,
			Loading,
			Loaded,
			Empty,
			Error
		}

		private sealed class RestrictionRowView
		{
			internal GameObject Root { get; }

			internal Toggle Toggle { get; }

			internal Text Label { get; }

			internal Text StateText { get; }

			internal RestrictionRowView(GameObject root, Toggle toggle, Text label, Text stateText)
			{
				Root = root;
				Toggle = toggle;
				Label = label;
				StateText = stateText;
			}
		}

		private const float ConfigurationPushDebounceSeconds = 0.15f;

		private const float ConfigurationRequestTimeoutSeconds = 5f;

		private const float RecentPlayersRequestTimeoutSeconds = 5f;

		private readonly Dictionary<long, PermittedRowView> _permittedRows = new Dictionary<long, PermittedRowView>();

		private readonly Dictionary<long, RecentPlayerRowView> _recentPlayerRows = new Dictionary<long, RecentPlayerRowView>();

		private readonly Dictionary<long, WardPlayerActivityEntry> _registeredPlayerActivity = new Dictionary<long, WardPlayerActivityEntry>();

		private readonly Dictionary<WardRestrictionOptions, RestrictionRowView> _restrictionRows = new Dictionary<WardRestrictionOptions, RestrictionRowView>();

		private readonly List<long> _permittedRowsToRemove = new List<long>();

		private readonly List<long> _recentPlayerRowsToRemove = new List<long>();

		private PrivateArea? _currentWard;

		private WardConfiguration _currentConfiguration;

		private WardConfiguration _authoritativeConfiguration;

		private WardConfiguration _pendingConfiguration;

		private GameObject? _root;

		private GameObject? _panel;

		private GameObject? _generalPageRoot;

		private GameObject? _restrictionsPageRoot;

		private RectTransform? _permittedContent;

		private RectTransform? _recentPlayersContent;

		private RectTransform? _restrictionsContent;

		private Text? _ownerValueText;

		private Text? _guildValueText;

		private Toggle? _autoCloseToggle;

		private Toggle? _warningSoundToggle;

		private Toggle? _warningFlashToggle;

		private Toggle? _areaMarkerRotationToggle;

		private Button? _previousPageButton;

		private Button? _nextPageButton;

		private Transform? _buildParent;

		private WardSettingsPage _currentPage;

		private bool _visible;

		private bool _suppressUiEvents;

		private bool _configurationPushPending;

		private bool _closeRequested;

		private float _nextConfigurationPushTime;

		private float _pendingConfigurationRequestedAt;

		private int _lastPermittedRevision = int.MinValue;

		private int _permittedRefreshGeneration;

		private int _recentPlayersRefreshGeneration;

		private long _pendingConfigurationRequestId;

		private long _pendingRecentPlayersRequestId;

		private float _recentPlayersRequestedAt;

		private bool _recentPlayersRequestInProgress;

		private bool _hasDeferredRecentPlayersSnapshot;

		private WardRecentPlayersSnapshot _deferredRecentPlayersSnapshot;

		private StatusRowView? _emptyPermittedRow;

		private StatusRowView? _recentPlayersStatusRow;

		private string _registeredPlayersSearchQuery = string.Empty;

		private string _recentPlayersSearchQuery = string.Empty;

		private ZDOID _searchQueryWardZdoId = ZDOID.None;

		private RecentPlayersListState _recentPlayersListState;

		internal static WardGuiController? Instance { get; private set; }

		private void Awake()
		{
			if ((Object)(object)Instance != (Object)null && (Object)(object)Instance != (Object)(object)this)
			{
				Object.Destroy((Object)(object)this);
				return;
			}
			Instance = this;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			GUIManager.OnCustomGUIAvailable += BuildGui;
			WardRecentPlayers.SnapshotReceived += HandleRecentPlayersSnapshot;
			BuildGui();
		}

		private void OnDestroy()
		{
			GUIManager.OnCustomGUIAvailable -= BuildGui;
			WardRecentPlayers.SnapshotReceived -= HandleRecentPlayersSnapshot;
			GUIManager.BlockInput(false);
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
		}

		private void Update()
		{
			if (!_visible)
			{
				TryOpenHoveredWardUi();
				return;
			}
			if (_closeRequested)
			{
				if ((Object)(object)_currentWard == (Object)null || !WardAccess.IsManagedWard(ManagedWardRef.FromArea(_currentWard), requireEnabled: false))
				{
					CompleteCloseWardUi();
					return;
				}
				if (HasPendingConfigurationRequest() && Time.unscaledTime - _pendingConfigurationRequestedAt >= 5f)
				{
					HandlePendingConfigurationRequestTimeout();
				}
				TryFlushDeferredConfigurationAfterRequestResolution();
				return;
			}
			if ((Object)(object)_root != (Object)null && !_root.activeSelf)
			{
				_root.SetActive(true);
			}
			if (Input.GetKeyDown((KeyCode)27))
			{
				CloseWardUi();
				return;
			}
			if ((Object)(object)_currentWard == (Object)null || !WardAccess.IsManagedWard(ManagedWardRef.FromArea(_currentWard), requireEnabled: false))
			{
				CloseWardUi();
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if (!WardAccess.CanConfigureWard(_currentWard, localPlayer) && !WardAdminDebugAccess.CanLocallyAttemptAnyWardControl(_currentWard, localPlayer))
			{
				CloseWardUi();
				return;
			}
			if (HasPendingConfigurationRequest() && Time.unscaledTime - _pendingConfigurationRequestedAt >= 5f)
			{
				HandlePendingConfigurationRequestTimeout();
			}
			if (!HasPendingConfigurationRequest())
			{
				RefreshAuthoritativeConfigurationFromWard();
			}
			if (!HasPendingConfigurationRequest() && _configurationPushPending && Time.unscaledTime >= _nextConfigurationPushTime)
			{
				PushPendingConfiguration();
			}
			if (WardPermittedSnapshots.GetRevision(_currentWard) != _lastPermittedRevision)
			{
				RefreshPermittedPlayers(force: false);
				RequestRecentPlayersSnapshot();
			}
			if (_pendingRecentPlayersRequestId != 0L && Time.unscaledTime - _recentPlayersRequestedAt >= 5f)
			{
				_pendingRecentPlayersRequestId = 0L;
				SetRecentPlayerRowsInteractable(interactable: true);
				ShowRecentPlayersStatus(WardLocalization.Localize("$stuw_ui_recent_players_error", "Could not load recent players."), isError: true, RecentPlayersListState.Error);
			}
		}

		internal bool TryOpenHoveredWardUi()
		{
			if (!Plugin.IsWardSettingsShortcutDown())
			{
				return false;
			}
			Player localPlayer = Player.m_localPlayer;
			GameObject val = (((Object)(object)localPlayer != (Object)null) ? localPlayer.m_hovering : null);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			ManagedWardRef ward = ManagedWardRef.FromArea(val.GetComponentInParent<PrivateArea>());
			if (!WardAccess.CanConfigureWard(ward, localPlayer) && !WardAdminDebugAccess.CanLocallyAttemptAnyWardControl(ward.Area, localPlayer))
			{
				return false;
			}
			OpenWardUi(ward.Area);
			return true;
		}

		internal void OpenWardUi(PrivateArea ward)
		{
			//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_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)
			if (!TryGetWardZdoId(ward, out var wardZdoId) || wardZdoId != _searchQueryWardZdoId)
			{
				_registeredPlayersSearchQuery = string.Empty;
				_recentPlayersSearchQuery = string.Empty;
				_searchQueryWardZdoId = wardZdoId;
			}
			BuildGui();
			if (!((Object)(object)_root == (Object)null))
			{
				_currentWard = ward;
				_closeRequested = false;
				_configurationPushPending = false;
				_lastPermittedRevision = int.MinValue;
				_currentPage = WardSettingsPage.General;
				_pendingRecentPlayersRequestId = 0L;
				_recentPlayersRequestInProgress = false;
				_hasDeferredRecentPlayersSnapshot = false;
				_registeredPlayerActivity.Clear();
				ClearPendingConfigurationRequest();
				_authoritativeConfiguration = WardSettings.GetConfiguration(ward);
				_currentConfiguration = _authoritativeConfiguration;
				RefreshStaticTexts();
				RefreshControls();
				RefreshPermittedPlayers(force: true);
				SetActivePage(WardSettingsPage.General);
				RequestRecentPlayersSnapshot();
				SetVisible(visible: true);
			}
		}

		internal void CloseWardUi()
		{
			_closeRequested = true;
			FlushPendingConfigurationPush();
			TryFlushDeferredConfigurationAfterRequestResolution();
			if (!_closeRequested)
			{
				return;
			}
			if (HasPendingConfigurationRequest() || _configurationPushPending)
			{
				if ((Object)(object)_root != (Object)null)
				{
					_root.SetActive(false);
				}
				GUIManager.BlockInput(false);
			}
			else
			{
				CompleteCloseWardUi();
			}
		}

		private void CompleteCloseWardUi()
		{
			_currentWard = null;
			_closeRequested = false;
			_configurationPushPending = false;
			_lastPermittedRevision = int.MinValue;
			_pendingRecentPlayersRequestId = 0L;
			_recentPlayersRequestInProgress = false;
			_hasDeferredRecentPlayersSnapshot = false;
			_registeredPlayerActivity.Clear();
			ClearPendingConfigurationRequest();
			SetVisible(visible: false);
		}

		private void BuildGui()
		{
			//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_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Expected O, but got Unknown
			//IL_00f0: 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_0106: 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_011b: 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_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: 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_01b3: 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_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: 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)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: 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_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: 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_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b0: Expected O, but got Unknown
			//IL_02b7: 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_02ec: Expected O, but got Unknown
			//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0329: Unknown result type (might be due to invalid IL or missing references)
			//IL_0333: Expected O, but got Unknown
			if ((Object)(object)GUIManager.CustomGUIFront == (Object)null)
			{
				return;
			}
			Localizer.ReloadCurrentLanguageIfAvailable();
			if ((Object)(object)_root != (Object)null)
			{
				Object.Destroy((Object)(object)_root);
			}
			ClearPermittedRows();
			ClearRecentPlayerRows();
			_emptyPermittedRow = null;
			_recentPlayersStatusRow = null;
			_lastPermittedRevision = int.MinValue;
			_restrictionRows.Clear();
			_generalPageRoot = null;
			_restrictionsPageRoot = null;
			_restrictionsContent = null;
			_recentPlayersContent = null;
			_previousPageButton = null;
			_nextPageButton = null;
			_buildParent = null;
			GUIManager instance = GUIManager.Instance;
			Vector2 panelSize = WardGuiLayoutSettings.GetPanelSize();
			_root = new GameObject("STUWardGUIRoot", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			_root.transform.SetParent(GUIManager.CustomGUIFront.transform, false);
			RectTransform component = _root.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			component.anchoredPosition = Vector2.zero;
			Image component2 = _root.GetComponent<Image>();
			((Graphic)component2).color = new Color(0f, 0f, 0f, 0.6f);
			((Graphic)component2).raycastTarget = true;
			_panel = instance.CreateWoodpanel(_root.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), WardGuiLayoutSettings.GetPanelOffset(), panelSize.x, panelSize.y, false);
			((Object)_panel).name = "STUWardPanel";
			_generalPageRoot = CreatePageRoot("STUWardGeneralPage", panelSize);
			_restrictionsPageRoot = CreatePageRoot("STUWardRestrictionsPage", panelSize);
			CreateLabel(WardLocalization.Localize("$stuw_ui_title", "Ward Settings"), WardGuiLayoutSettings.GetTitlePosition(), 34, WardGuiLayoutSettings.GetTitleSize().x, WardGuiLayoutSettings.GetTitleSize().y, (TextAnchor)4, instance.AveriaSerifBold, instance.ValheimOrange);
			Vector2 ownerGuildLabelSize = WardGuiLayoutSettings.GetOwnerGuildLabelSize();
			_ownerValueText = CreateLabel(string.Empty, WardGuiLayoutSettings.GetOwnerPosition(), 22, ownerGuildLabelSize.x, ownerGuildLabelSize.y, (TextAnchor)3, instance.AveriaSerifBold, instance.ValheimBeige);
			_guildValueText = CreateLabel(string.Empty, WardGuiLayoutSettings.GetGuildPosition(), 20, ownerGuildLabelSize.x, ownerGuildLabelSize.y, (TextAnchor)3, instance.AveriaSerif, instance.ValheimBeige);
			((UnityEvent)CreateButton(WardLocalization.Localize("$stuw_ui_close", "Close"), WardGuiLayoutSettings.GetCloseButtonPosition(), 170f, 42f).onClick).AddListener(new UnityAction(CloseWardUi));
			_previousPageButton = CreateButton("<", WardGuiLayoutSettings.GetPageArrowButtonPosition(), 54f, 42f);
			((UnityEvent)_previousPageButton.onClick).AddListener((UnityAction)delegate
			{
				SetActivePage(WardSettingsPage.General);
			});
			StylePageArrowButton(_previousPageButton);
			_nextPageButton = CreateButton(">", WardGuiLayoutSettings.GetPageArrowButtonPosition(), 54f, 42f);
			((UnityEvent)_nextPageButton.onClick).AddListener((UnityAction)delegate
			{
				SetActivePage(WardSettingsPage.Restrictions);
			});
			StylePageArrowButton(_nextPageButton);
			_buildParent = _generalPageRoot.transform;
			BuildTrustedPlayers(instance);
			BuildRecentPlayers(instance);
			_buildParent = _restrictionsPageRoot.transform;
			BuildTopControls(instance);
			BuildRestrictions();
			_buildParent = null;
			SetActivePage(_currentPage);
			SetVisible(_visible);
			if (_visible && (Object)(object)_currentWard != (Object)null)
			{
				RefreshStaticTexts();
				RefreshControls();
				RefreshPermittedPlayers(force: true);
				if (_currentPage == WardSettingsPage.General)
				{
					RequestRecentPlayersSnapshot();
				}
			}
		}

		private void BuildTopControls(GUIManager gui)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//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_004e: 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_0086: 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_009f: Expected O, but got Unknown
			GameObject val = new GameObject("STUWardBehaviorControls", new Type[2]
			{
				typeof(RectTransform),
				typeof(GridLayoutGroup)
			});
			val.transform.SetParent(GetBuildParent(), false);
			Vector2 behaviorControlsGridSize = WardGuiLayoutSettings.GetBehaviorControlsGridSize();
			ConfigureRect(val.GetComponent<RectTransform>(), WardGuiLayoutSettings.GetBehaviorControlsGridPosition(), behaviorControlsGridSize.x, behaviorControlsGridSize.y);
			GridLayoutGroup component = val.GetComponent<GridLayoutGroup>();
			component.startCorner = (Corner)0;
			component.startAxis = (Axis)0;
			((LayoutGroup)component).childAlignment = (TextAnchor)0;
			component.cellSize = WardGuiLayoutSettings.GetRestrictionCellSize();
			component.spacing = WardGuiLayoutSettings.GetRestrictionCellSpacing();
			((LayoutGroup)component).padding = new RectOffset(8, 8, 8, 8);
			component.constraint = (Constraint)1;
			component.constraintCount = 2;
			_warningSoundToggle = CreateBehaviorToggleRow(val.transform, "WardAlertSound", WardLocalization.Localize("$stuw_ui_warning_sound", "Ward alert sound"), gui);
			((UnityEvent<bool>)(object)_warningSoundToggle.onValueChanged).AddListener((UnityAction<bool>)OnWarningSoundToggleChanged);
			_warningFlashToggle = CreateBehaviorToggleRow(val.transform, "WardAlertVisualEffect", WardLocalization.Localize("$stuw_ui_warning_flash", "Ward alert visual effect"), gui);
			((UnityEvent<bool>)(object)_warningFlashToggle.onValueChanged).AddListener((UnityAction<bool>)OnWarningFlashToggleChanged);
			_areaMarkerRotationToggle = CreateBehaviorToggleRow(val.transform, "WardRangeRotation", WardLocalization.Localize("$stuw_ui_area_marker_rotation", "Ward range rotation"), gui);
			((UnityEvent<bool>)(object)_areaMarkerRotationToggle.onValueChanged).AddListener((UnityAction<bool>)OnAreaMarkerRotationToggleChanged);
			_autoCloseToggle = CreateBehaviorToggleRow(val.transform, "DoorAutoClose", WardLocalization.Localize("$stuw_ui_auto_close", "Door auto-close"), gui);
			((UnityEvent<bool>)(object)_autoCloseToggle.onValueChanged).AddListener((UnityAction<bool>)OnAutoCloseToggleChanged);
		}

		private Toggle CreateBehaviorToggleRow(Transform parent, string name, string labelText, GUIManager gui)
		{
			//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_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_0042: 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_0073: 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_009c: 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_00e8: 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_010e: 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_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: 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_0187: Unknown result type (might be due to invalid IL or missing references)
			Vector2 restrictionCellSize = WardGuiLayoutSettings.GetRestrictionCellSize();
			GameObject val = new GameObject(name, new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.transform.SetParent(parent, false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.SetSizeWithCurrentAnchors((Axis)0, restrictionCellSize.x);
			component.SetSizeWithCurrentAnchors((Axis)1, restrictionCellSize.y);
			((Graphic)val.GetComponent<Image>()).color = new Color(0f, 0f, 0f, 0.18f);
			Toggle result = CreateCenteredToggle(val.transform, new Vector2((0f - restrictionCellSize.x) * 0.5f + 28f, 0f), WardGuiLayoutSettings.GetBehaviorToggleSize());
			GameObject val2 = new GameObject("BehaviorName", new Type[2]
			{
				typeof(RectTransform),
				typeof(Text)
			});
			val2.transform.SetParent(val.transform, false);
			RectTransform component2 = val2.GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(0.5f, 0.5f);
			component2.anchorMax = new Vector2(0.5f, 0.5f);
			component2.pivot = new Vector2(0f, 0.5f);
			component2.anchoredPosition = new Vector2((0f - restrictionCellSize.x) * 0.5f + 58f, 0f);
			component2.SetSizeWithCurrentAnchors((Axis)0, restrictionCellSize.x - 72f);
			component2.SetSizeWithCurrentAnchors((Axis)1, restrictionCellSize.y - 8f);
			Text component3 = val2.GetComponent<Text>();
			gui.ApplyTextStyle(component3, gui.AveriaSerifBold, gui.ValheimBeige, 20, false);
			component3.text = labelText;
			component3.alignment = (TextAnchor)3;
			component3.horizontalOverflow = (HorizontalWrapMode)0;
			component3.verticalOverflow = (VerticalWrapMode)0;
			return result;
		}

		private void BuildTrustedPlayers(GUIManager gui)
		{
			//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_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_0017: 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_002b: 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_003f: 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_0074: 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)
			Vector2 permittedListSize = WardGuiLayoutSettings.GetPermittedListSize();
			Vector2 permittedListPosition = WardGuiLayoutSettings.GetPermittedListPosition();
			Vector2 registeredPlayersHeaderPosition = WardGuiLayoutSettings.GetRegisteredPlayersHeaderPosition();
			Vector2 playerListHeaderLabelSize = WardGuiLayoutSettings.GetPlayerListHeaderLabelSize();
			CreateLabel(WardLocalization.Localize("$stuw_ui_registered_players", "Individually trusted players"), registeredPlayersHeaderPosition, 24, playerListHeaderLabelSize.x, playerListHeaderLabelSize.y, (TextAnchor)3, gui.AveriaSerifBold, gui.ValheimOrange);
			CreatePlayerSearchInput(WardGuiLayoutSettings.GetRegisteredPlayersSearchPosition(), _registeredPlayersSearchQuery, OnRegisteredPlayersSearchChanged, "STUWardRegisteredPlayersSearch");
			_permittedContent = CreatePlayerListContent(gui, "STUWardPermittedPlayers", permittedListPosition, permittedListSize);
			_ = (Object)(object)_permittedContent == (Object)null;
		}

		private void BuildRecentPlayers(GUIManager gui)
		{
			//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_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_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: 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)
			Vector2 recentPlayersListSize = WardGuiLayoutSettings.GetRecentPlayersListSize();
			Vector2 playerListHeaderLabelSize = WardGuiLayoutSettings.GetPlayerListHeaderLabelSize();
			CreateLabel(WardLocalization.Localize("$stuw_ui_unregistered_players", "Unregistered players"), WardGuiLayoutSettings.GetRecentPlayersHeaderPosition(), 24, playerListHeaderLabelSize.x, playerListHeaderLabelSize.y, (TextAnchor)3, gui.AveriaSerifBold, gui.ValheimOrange);
			CreatePlayerSearchInput(WardGuiLayoutSettings.GetRecentPlayersSearchPosition(), _recentPlayersSearchQuery, OnRecentPlayersSearchChanged, "STUWardRecentPlayersSearch");
			_recentPlayersContent = CreatePlayerListContent(gui, "STUWardRecentPlayers", WardGuiLayoutSettings.GetRecentPlayersListPosition(), recentPlayersListSize);
			if (!((Object)(object)_recentPlayersContent == (Object)null))
			{
				ShowRecentPlayersStatus(WardLocalization.Localize("$stuw_ui_recent_players_loading", "Loading recent players..."), isError: false, RecentPlayersListState.Loading);
			}
		}

		private RectTransform? CreatePlayerListContent(GUIManager gui, string objectName, Vector2 position, Vector2 size)
		{
			//IL_0019: 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_003e: 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_0051: 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_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Expected O, but got Unknown
			GameObject obj = gui.CreateScrollView(_generalPageRoot.transform, false, true, 20f, 6f, gui.ValheimScrollbarHandleColorBlock, new Color(0f, 0f, 0f, 0.35f), size.x, size.y);
			ConfigureRect(obj.GetComponent<RectTransform>(), position, size.x, size.y);
			((Object)obj).name = objectName;
			Transform obj2 = obj.transform.Find("Scroll View/Viewport/Content");
			RectTransform val = (RectTransform)(object)((obj2 is RectTransform) ? obj2 : null);
			if ((Object)(object)val == (Object)null)
			{
				Plugin.Log.LogError((object)("Failed to find the Content object for " + objectName + "."));
				return null;
			}
			VerticalLayoutGroup component = ((Component)val).GetComponent<VerticalLayoutGroup>();
			if ((Object)(object)component == (Object)null)
			{
				Plugin.Log.LogError((object)("Failed to find the VerticalLayoutGroup for " + objectName + "."));
				return null;
			}
			((LayoutGroup)component).childAlignment = (TextAnchor)0;
			((HorizontalOrVerticalLayoutGroup)component).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)component).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)component).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)component).spacing = 6f;
			((LayoutGroup)component).padding = new RectOffset(8, 8, 8, 8);
			return val;
		}

		private void RequestRecentPlayersSnapshot()
		{
			if (!((Object)(object)_currentWard == (Object)null) && !((Object)(object)_recentPlayersContent == (Object)null))
			{
				if (_recentPlayersListState != RecentPlayersListState.Loaded)
				{
					ShowRecentPlayersStatus(WardLocalization.Localize("$stuw_ui_recent_players_loading", "Loading recent players..."), isError: false, RecentPlayersListState.Loading);
				}
				BeginRecentPlayersRequest();
				long num = WardRecentPlayers.RequestSnapshot(_currentWard);
				EndRecentPlayersRequest(num);
				if (num == 0L)
				{
					_pendingRecentPlayersRequestId = 0L;
					SetRecentPlayerRowsInteractable(interactable: true);
					ShowRecentPlayersStatus(WardLocalization.Localize("$stuw_ui_recent_players_error", "Could not load recent players."), isError: true, RecentPlayersListState.Error);
				}
				else
				{
					_pendingRecentPlayersRequestId = num;
					_recentPlayersRequestedAt = Time.unscaledTime;
					ApplyDeferredRecentPlayersSnapshot(num);
				}
			}
		}

		private void HandleRecentPlayersSnapshot(WardRecentPlayersSnapshot snapshot)
		{
			if (_recentPlayersRequestInProgress)
			{
				if (IsSnapshotForCurrentWard(snapshot))
				{
					_deferredRecentPlayersSnapshot = snapshot;
					_hasDeferredRecentPlayersSnapshot = true;
				}
			}
			else
			{
				ApplyRecentPlayersSnapshot(snapshot);
			}
		}

		private void ApplyRecentPlayersSnapshot(WardRecentPlayersSnapshot snapshot)
		{
			if (!((Object)(object)_currentWard == (Object)null) && !((Object)(object)_recentPlayersContent == (Object)null) && snapshot.RequestId != 0L && snapshot.RequestId == _pendingRecentPlayersRequestId && IsSnapshotForCurrentWard(snapshot))
			{
				_pendingRecentPlayersRequestId = 0L;
				RefreshRegisteredPlayerActivity(snapshot.RegisteredActivity);
				RefreshRecentPlayers(snapshot.Players);
				SetRecentPlayerRowsInteractable(interactable: true);
				RefreshPermittedPlayers(force: true);
			}
		}

		private void RefreshRegisteredPlayerActivity(IReadOnlyList<WardPlayerActivityEntry> activity)
		{
			_registeredPlayerActivity.Clear();
			for (int i = 0; i < activity.Count; i++)
			{
				WardPlayerActivityEntry value = activity[i];
				if (value.PlayerId != 0L)
				{
					_registeredPlayerActivity[value.PlayerId] = value;
				}
			}
		}

		private bool IsSnapshotForCurrentWard(WardRecentPlayersSnapshot snapshot)
		{
			//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 ((Object)(object)_currentWard != (Object)null && TryGetWardZdoId(_currentWard, out var wardZdoId))
			{
				return snapshot.WardZdoId == wardZdoId;
			}
			return false;
		}

		private void BeginRecentPlayersRequest()
		{
			_recentPlayersRequestInProgress = true;
			_hasDeferredRecentPlayersSnapshot = false;
			_deferredRecentPlayersSnapshot = default(WardRecentPlayersSnapshot);
		}

		private void EndRecentPlayersRequest(long requestId)
		{
			_recentPlayersRequestInProgress = false;
			if (requestId == 0L)
			{
				_hasDeferredRecentPlayersSnapshot = false;
				_deferredRecentPlayersSnapshot = default(WardRecentPlayersSnapshot);
			}
		}

		private void ApplyDeferredRecentPlayersSnapshot(long requestId)
		{
			if (_hasDeferredRecentPlayersSnapshot)
			{
				WardRecentPlayersSnapshot deferredRecentPlayersSnapshot = _deferredRecentPlayersSnapshot;
				_hasDeferredRecentPlayersSnapshot = false;
				_deferredRecentPlayersSnapshot = default(WardRecentPlayersSnapshot);
				if (deferredRecentPlayersSnapshot.RequestId == requestId)
				{
					ApplyRecentPlayersSnapshot(deferredRecentPlayersSnapshot);
				}
			}
		}

		private void RefreshRecentPlayers(IReadOnlyList<WardRecentPlayerEntry> players)
		{
			if ((Object)(object)_recentPlayersContent == (Object)null)
			{
				return;
			}
			if (players.Count == 0)
			{
				foreach (RecentPlayerRowView value3 in _recentPlayerRows.Values)
				{
					value3.Root.SetActive(false);
				}
				ShowRecentPlayersStatus(WardLocalization.Localize("$stuw_ui_no_unregistered_players", "No unregistered players seen in the last 14 days."), isError: false, RecentPlayersListState.Empty);
				return;
			}
			if (_recentPlayersStatusRow != null)
			{
				_recentPlayersStatusRow.Root.SetActive(false);
			}
			_recentPlayersRefreshGeneration++;
			for (int i = 0; i < players.Count; i++)
			{
				WardRecentPlayerEntry wardRecentPlayerEntry = players[i];
				if (!_recentPlayerRows.TryGetValue(wardRecentPlayerEntry.PlayerId, out RecentPlayerRowView value))
				{
					value = CreateRecentPlayerRow(wardRecentPlayerEntry.PlayerId);
					_recentPlayerRows[wardRecentPlayerEntry.PlayerId] = value;
				}
				value.LastSeenGeneration = _recentPlayersRefreshGeneration;
				string playerName = (string.IsNullOrWhiteSpace(wardRecentPlayerEntry.Name) ? wardRecentPlayerEntry.PlayerId.ToString() : wardRecentPlayerEntry.Name);
				value.NameText.text = BuildPlayerDisplayText(playerName, wardRecentPlayerEntry.GuildName, wardRecentPlayerEntry.AccountId);
				value.SearchText = BuildPlayerSearchText(wardRecentPlayerEntry.Name, wardRecentPlayerEntry.GuildName, wardRecentPlayerEntry.AccountId, wardRecentPlayerEntry.PlayerId);
				value.StatusText.text = BuildPlayerActivityStatus(wardRecentPlayerEntry.IsOnline, wardRecentPlayerEntry.LastSeenUtcTicks);
				value.Root.transform.SetSiblingIndex(i);
			}
			_recentPlayerRowsToRemove.Clear();
			foreach (KeyValuePair<long, RecentPlayerRowView> recentPlayerRow in _recentPlayerRows)
			{
				if (recentPlayerRow.Value.LastSeenGeneration != _recentPlayersRefreshGeneration)
				{
					_recentPlayerRowsToRemove.Add(recentPlayerRow.Key);
				}
			}
			for (int j = 0; j < _recentPlayerRowsToRemove.Count; j++)
			{
				long key = _recentPlayerRowsToRemove[j];
				if (_recentPlayerRows.TryGetValue(key, out RecentPlayerRowView value2))
				{
					Object.Destroy((Object)(object)value2.Root);
					_recentPlayerRows.Remove(key);
				}
			}
			_recentPlayersListState = RecentPlayersListState.Loaded;
			ApplyRecentPlayersFilter();
		}

		private void OnRecentPlayersSearchChanged(string query)
		{
			_recentPlayersSearchQuery = query ?? string.Empty;
			ApplyRecentPlayersFilter();
		}

		private void ApplyRecentPlayersFilter()
		{
			if ((Object)(object)_recentPlayersContent == (Object)null || _recentPlayersListState != RecentPlayersListState.Loaded)
			{
				return;
			}
			if (_recentPlayersStatusRow != null)
			{
				_recentPlayersStatusRow.Root.SetActive(false);
			}
			string text = _recentPlayersSearchQuery.Trim();
			int num = 0;
			foreach (RecentPlayerRowView value in _recentPlayerRows.Values)
			{
				bool flag = MatchesPlayerSearch(value.SearchText, text);
				value.Root.SetActive(flag);
				if (flag)
				{
					num++;
				}
			}
			if (num == 0 && text.Length > 0)
			{
				ShowRecentPlayersStatus(WardLocalization.Localize("$stuw_ui_no_matching_players", "No matching players."), isError: false, RecentPlayersListState.Loaded);
			}
		}

		private RecentPlayerRowView CreateRecentPlayerRow(long playerId)
		{
			//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_001f: 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_0073: 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_00ba: 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_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Expected O, but got Unknown
			Vector2 recentPlayersListSize = WardGuiLayoutSettings.GetRecentPlayersListSize();
			float num = Mathf.Max(560f, recentPlayersListSize.x - 72f);
			GameObject val = CreatePlayerRowRoot((Transform)(object)_recentPlayersContent, "RecentPlayerRow", num);
			Text val2 = CreatePlayerRowText(val.transform, "PlayerName", new Vector2((0f - num) * 0.5f + 10f, 0f), num - 318f, (TextAnchor)3, GUIManager.Instance.ValheimBeige);
			val2.horizontalOverflow = (HorizontalWrapMode)0;
			Text statusText = CreatePlayerRowText(val.transform, "PlayerStatus", new Vector2(num * 0.5f - 120f - 164f, 0f), 150f, (TextAnchor)5, GUIManager.Instance.ValheimYellow);
			Button val3 = CreateAnchoredButton(val.transform, WardLocalization.Localize("$stuw_ui_add", "Add"), new Vector2(num * 0.5f - 60f - 4f, 0f), 120f, 32f);
			((UnityEvent)val3.onClick).AddListener((UnityAction)delegate
			{
				RequestAddRecentPlayer(playerId);
			});
			return new RecentPlayerRowView(val, val2, statusText, val3);
		}

		private static GameObject CreatePlayerRowRoot(Transform parent, string name, float rowWidth)
		{
			//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_0040: 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_0073: 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_0095: Expected O, but got Unknown
			GameObject val = new GameObject(name, new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(LayoutElement)
			});
			val.transform.SetParent(parent, false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.SetSizeWithCurrentAnchors((Axis)0, rowWidth);
			component.SetSizeWithCurrentAnchors((Axis)1, 46f);
			((Graphic)val.GetComponent<Image>()).color = new Color(0f, 0f, 0f, 0.18f);
			LayoutElement component2 = val.GetComponent<LayoutElement>();
			component2.preferredHeight = 46f;
			component2.preferredWidth = rowWidth;
			return val;
		}

		private static Text CreatePlayerRowText(Transform parent, string name, Vector2 position, float width, TextAnchor alignment, Color color)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: 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_0059: 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_0079: 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_00b1: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[2]
			{
				typeof(RectTransform),
				typeof(Text)
			});
			val.transform.SetParent(parent, false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 0.5f);
			component.anchorMax = new Vector2(0.5f, 0.5f);
			component.pivot = new Vector2(0f, 0.5f);
			component.anchoredPosition = position;
			component.SetSizeWithCurrentAnchors((Axis)0, width);
			component.SetSizeWithCurrentAnchors((Axis)1, 38f);
			Text component2 = val.GetComponent<Text>();
			GUIManager instance = GUIManager.Instance;
			instance.ApplyTextStyle(component2, instance.AveriaSerifBold, color, 18, false);
			component2.alignment = alignment;
			component2.horizontalOverflow = (HorizontalWrapMode)1;
			component2.verticalOverflow = (VerticalWrapMode)0;
			return component2;
		}

		private void RequestAddRecentPlayer(long playerId)
		{
			if (!((Object)(object)_currentWard == (Object)null))
			{
				SetRecentPlayerRowsInteractable(interactable: false);
				BeginRecentPlayersRequest();
				long num = WardRecentPlayers.RequestAdd(_currentWard, playerId);
				EndRecentPlayersRequest(num);
				if (num == 0L)
				{
					_pendingRecentPlayersRequestId = 0L;
					SetRecentPlayerRowsInteractable(interactable: true);
					ShowRecentPlayersStatus(WardLocalization.Localize("$stuw_ui_recent_players_error", "Could not load recent players."), isError: true, RecentPlayersListState.Error);
				}
				else
				{
					_pendingRecentPlayersRequestId = num;
					_recentPlayersRequestedAt = Time.unscaledTime;
					ApplyDeferredRecentPlayersSnapshot(num);
				}
			}
		}

		private void ShowRecentPlayersStatus(string text, bool isError, RecentPlayersListState state)
		{
			//IL_008d: 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)
			if ((Object)(object)_recentPlayersContent == (Object)null)
			{
				return;
			}
			foreach (RecentPlayerRowView value in _recentPlayerRows.Values)
			{
				value.Root.SetActive(false);
			}
			EnsureRecentPlayersStatusRow();
			_recentPlayersStatusRow.Text.text = text;
			((Graphic)_recentPlayersStatusRow.Text).color = (Color)(isError ? new Color(0.85f, 0.35f, 0.25f) : GUIManager.Instance.ValheimBeige);
			_recentPlayersStatusRow.Root.transform.SetSiblingIndex(0);
			_recentPlayersStatusRow.Root.SetActive(true);
			_recentPlayersListState = state;
		}

		private void SetRecentPlayerRowsInteractable(bool interactable)
		{
			foreach (RecentPlayerRowView value in _recentPlayerRows.Values)
			{
				((Selectable)value.AddButton).interactable = interactable;
			}
		}

		private void EnsureRecentPlayersStatusRow()
		{
			//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_0064: 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)
			if (_recentPlayersStatusRow == null && !((Object)(object)_recentPlayersContent == (Object)null))
			{
				Vector2 recentPlayersListSize = WardGuiLayoutSettings.GetRecentPlayersListSize();
				float num = Mathf.Max(560f, recentPlayersListSize.x - 72f);
				GameObject val = CreatePlayerRowRoot((Transform)(object)_recentPlayersContent, "RecentPlayersStatusRow", num);
				Text text = CreatePlayerRowText(val.transform, "Status", new Vector2((0f - num) * 0.5f + 10f, 0f), num - 24f, (TextAnchor)3, GUIManager.Instance.ValheimBeige);
				_recentPlayersStatusRow = new StatusRowView(val, text);
			}
		}

		private static string BuildPlayerActivityStatus(bool isOnline, long lastSeenUtcTicks)
		{
			if (isOnline)
			{
				return WardLocalization.Localize("$stuw_ui_online", "Online");
			}
			if (lastSeenUtcTicks <= 0 || lastSeenUtcTicks > DateTime.MaxValue.Ticks)
			{
				return WardLocalization.Localize("$stuw_ui_last_seen_unavailable", "Last seen unavailable");
			}
			DateTime dateTime = new DateTime(lastSeenUtcTicks, DateTimeKind.Utc);
			TimeSpan timeSpan = DateTime.UtcNow - dateTime;
			if (timeSpan < TimeSpan.Zero || timeSpan.TotalMinutes < 1.0)
			{
				return WardLocalization.Localize("$stuw_ui_last_seen_just_now", "Seen just now");
			}
			if (timeSpan.TotalHours < 1.0)
			{
				return WardLocalization.LocalizeFormat("$stuw_ui_last_seen_minutes_ago", "Seen {0}m ago", Mathf.Max(1, Mathf.FloorToInt((float)timeSpan.TotalMinutes)));
			}
			if (timeSpan.TotalDays < 1.0)
			{
				return WardLocalization.LocalizeFormat("$stuw_ui_last_seen_hours_ago", "Seen {0}h ago", Mathf.Max(1, Mathf.FloorToInt((float)timeSpan.TotalHours)));
			}
			return WardLocalization.LocalizeFormat("$stuw_ui_last_seen_days_ago", "Seen {0}d ago", Mathf.Max(1, Mathf.FloorToInt((float)timeSpan.TotalDays)));
		}

		private static bool TryGetWardZdoId(PrivateArea ward, out ZDOID wardZdoId)
		{
			//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_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_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)
			wardZdoId = ZDOID.None;
			ZDO val = (((Object)(object)ward.m_nview != (Object)null && ward.m_nview.IsValid()) ? ward.m_nview.GetZDO() : null);
			if (val == null)
			{
				return false;
			}
			wardZdoId = val.m_uid;
			return wardZdoId != ZDOID.None;
		}

		private void SetVisible(bool visible)
		{
			_visible = visible;
			if ((Object)(object)_root != (Object)null)
			{
				_root.SetActive(visible);
			}
			GUIManager.BlockInput(visible);
		}

		private void RefreshStaticTexts()
		{
			if (!((Object)(object)_currentWard == (Object)null) && !((Object)(object)_ownerValueText == (Object)null) && !((Object)(object)_guildValueText == (Object)null))
			{
				_ownerValueText.text = WardLocalization.LocalizeFormat("$stuw_ui_owner", "Owner: {0}", WardPrivateAreaSafeAccess.GetCreatorName(_currentWard));
				string wardGuildName = GuildsCompat.GetWardGuildName(_currentWard);
				_guildValueText.text = WardLocalization.LocalizeFormat("$stuw_ui_guild", "Guild: {0}", string.IsNullOrWhiteSpace(wardGuildName) ? "-" : wardGuildName);
			}
		}

		private void RefreshControls()
		{
			if (!((Object)(object)_autoCloseToggle == (Object)null) && !((Object)(object)_warningSoundToggle == (Object)null) && !((Object)(object)_warningFlashToggle == (Object)null) && !((Object)(object)_areaMarkerRotationToggle == (Object)null))
			{
				_suppressUiEvents = true;
				_autoCloseToggle.isOn = _currentConfiguration.AutoCloseEnabled;
				_warningSoundToggle.isOn = _currentConfiguration.WarningSoundEnabled;
				_warningFlashToggle.isOn = _currentConfiguration.WarningFlashEnabled;
				_areaMarkerRotationToggle.isOn = _currentConfiguration.AreaMarkerRotationEnabled;
				RefreshRestrictionRows();
				_suppressUiEvents = false;
			}
		}

		private void RefreshPermittedPlayers(bool force)
		{
			if ((Object)(object)_currentWard == (Object)null || (Object)(object)_permittedContent == (Object)null)
			{
				return;
			}
			int revision = WardPermittedSnapshots.GetRevision(_currentWard);
			if (!force && revision == _lastPermittedRevision)
			{
				return;
			}
			_lastPermittedRevision = revision;
			List<KeyValuePair<long, string>> permittedPlayers = WardPrivateAreaSafeAccess.GetPermittedPlayers(_currentWard);
			if (permittedPlayers.Count == 0)
			{
				ClearPermittedRows();
				EnsureEmptyPermittedRow();
				UpdateText(_emptyPermittedRow.Text, WardLocalization.Localize("$stuw_ui_no_registered_players", "No individually trusted players."));
				_emptyPermittedRow.Root.SetActive(true);
				_emptyPermittedRow.Root.transform.SetSiblingIndex(0);
				return;
			}
			if (_emptyPermittedRow != null)
			{
				_emptyPermittedRow.Root.SetActive(false);
			}
			permittedPlayers.Sort((KeyValuePair<long, string> left, KeyValuePair<long, string> right) => string.Compare(left.Value, right.Value, StringComparison.OrdinalIgnoreCase));
			_permittedRefreshGeneration++;
			for (int num = 0; num < permittedPlayers.Count; num++)
			{
				KeyValuePair<long, string> keyValuePair = permittedPlayers[num];
				if (!_permittedRows.TryGetValue(keyValuePair.Key, out PermittedRowView value))
				{
					value = CreatePermittedRow(keyValuePair.Key);
					_permittedRows[keyValuePair.Key] = value;
				}
				value.LastSeenGeneration = _permittedRefreshGeneration;
				GetPermittedPlayerIdentity(_currentWard, keyValuePair.Key, out string guildName, out string accountId);
				string playerName = (string.IsNullOrWhiteSpace(keyValuePair.Value) ? keyValuePair.Key.ToString() : keyValuePair.Value);
				UpdateText(value.NameText, BuildPlayerDisplayText(playerName, guildName, accountId));
				value.StatusText.text = (_registeredPlayerActivity.TryGetValue(keyValuePair.Key, out var value2) ? BuildPlayerActivityStatus(value2.IsOnline, value2.LastSeenUtcTicks) : BuildPlayerActivityStatus(isOnline: false, 0L));
				value.SearchText = BuildPlayerSearchText(keyValuePair.Value, guildName, accountId, keyValuePair.Key);
				value.Root.transform.SetSiblingIndex(num);
			}
			_permittedRowsToRemove.Clear();
			foreach (KeyValuePair<long, PermittedRowView> permittedRow in _permittedRows)
			{
				if (permittedRow.Value.LastSeenGeneration != _permittedRefreshGeneration)
				{
					_permittedRowsToRemove.Add(permittedRow.Key);
				}
			}
			for (int num2 = 0; num2 < _permittedRowsToRemove.Count; num2++)
			{
				long key = _permittedRowsToRemove[num2];
				if (_permittedRows.TryGetValue(key, out PermittedRowView value3))
				{
					Object.Destroy((Object)(object)value3.Root);
					_permittedRows.Remove(key);
				}
			}
			ApplyRegisteredPlayersFilter();
		}

		private void OnRegisteredPlayersSearchChanged(string query)
		{
			_registeredPlayersSearchQuery = query ?? string.Empty;
			ApplyRegisteredPlayersFilter();
		}

		private void ApplyRegisteredPlayersFilter()
		{
			if ((Object)(object)_permittedContent == (Object)null || _permittedRows.Count == 0)
			{
				return;
			}
			string text = _registeredPlayersSearchQuery.Trim();
			int num = 0;
			foreach (PermittedRowView value in _permittedRows.Values)
			{
				bool flag = MatchesPlayerSearch(value.SearchText, text);
				value.Root.SetActive(flag);
				if (flag)
				{
					num++;
				}
			}
			if (_emptyPermittedRow == null)
			{
				EnsureEmptyPermittedRow();
			}
			if (num == 0 && text.Length > 0)
			{
				UpdateText(_emptyPermittedRow.Text, WardLocalization.Localize("$stuw_ui_no_matching_players", "No matching players."));
				_emptyPermittedRow.Root.transform.SetSiblingIndex(_permittedRows.Count);
				_emptyPermittedRow.Root.SetActive(true);
			}
			else if (_emptyPermittedRow != null)
			{
				_emptyPermittedRow.Root.SetActive(false);
			}
		}

		private PermittedRowView CreatePermittedRow(long playerId)
		{
			//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_001f: 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_004a: 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_00db: 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_0111: 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_0156: 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_0180: Expected O, but got Unknown
			Vector2 permittedListSize = WardGuiLayoutSettings.GetPermittedListSize();
			float num = Mathf.Max(560f, permittedListSize.x - 72f);
			GameObject val = CreatePlayerRowRoot((Transform)(object)_permittedContent, "PermittedPlayerRow", num);
			Vector2 registeredPlayersRemoveButtonPosition = WardGuiLayoutSettings.GetRegisteredPlayersRemoveButtonPosition();
			float num2 = Mathf.Clamp(registeredPlayersRemoveButtonPosition.x, (0f - num) * 0.5f + 65f + 10f, num * 0.5f - 65f - 4f);
			float num3 = (0f - num) * 0.5f + 10f;
			float num4 = num2 - 65f - 10f - 150f;
			float width = Mathf.Max(220f, num4 - 12f - num3);
			Text val2 = CreatePlayerRowText(val.transform, "PlayerName", new Vector2(num3, 0f), width, (TextAnchor)3, GUIManager.Instance.ValheimBeige);
			val2.horizontalOverflow = (HorizontalWrapMode)0;
			Text val3 = CreatePlayerRowText(val.transform, "PlayerStatus", new Vector2(num4, 0f), 150f, (TextAnchor)5, GUIManager.Instance.ValheimYellow);
			val3.resizeTextForBestFit = true;
			val3.resizeTextMinSize = 13;
			val3.resizeTextMaxSize = 18;
			((UnityEvent)CreateAnchoredButton(val.transform, WardLocalization.Localize("$stuw_ui_remove", "Remove"), new Vector2(num2, registeredPlayersRemoveButtonPosition.y), 130f, 32f).onClick).AddListener((UnityAction)delegate
			{
				if (!((Object)(object)_currentWard == (Object)null))
				{
					WardSettings.RequestRemovePermitted(_currentWard, playerId);
					RequestRecentPlayersSnapshot();
				}
			});
			return new PermittedRowView(val, val2, val3);
		}

		private void EnsureEmptyPermittedRow()
		{
			//IL_0009: 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_0014: 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)
			if (_emptyPermittedRow == null)
			{
				Vector2 permittedListSize = WardGuiLayoutSettings.GetPermittedListSize();
				float num = Mathf.Max(560f, permittedListSize.x - 72f);
				GameObject val = CreatePlayerRowRoot((Transform)(object)_permittedContent, "PermittedPlayerRowEmpty", num);
				Text text = CreatePlayerRowText(val.transform, "PlayerName", new Vector2((0f - num) * 0.5f + 10f, 0f), num - 24f, (TextAnchor)3, GUIManager.Instance.ValheimBeige);
				_emptyPermittedRow = new StatusRowView(val, text);
			}
		}

		private static void UpdateText(Text target, string text)
		{
			if (!string.Equals(target.text, text, StringComparison.Ordinal))
			{
				target.text = text;
			}
		}

		private void ClearPermittedRows()
		{
			foreach (PermittedRowView value in _permittedRows.Values)
			{
				Object.Destroy((Object)(object)value.Root);
			}
			_permittedRows.Clear();
			_permittedRowsToRemove.Clear();
			_permittedRefreshGeneration = 0;
			if (_emptyPermittedRow != null)
			{
				Object.Destroy((Object)(object)_emptyPermittedRow.Root);
				_emptyPermittedRow = null;
			}
		}

		private void ClearRecentPlayerRows()
		{
			foreach (RecentPlayerRowView value in _recentPlayerRows.Values)
			{
				Object.Destroy((Object)(object)value.Root);
			}
			_recentPlayerRows.Clear();
			_recentPlayerRowsToRemove.Clear();
			_recentPlayersRefreshGeneration = 0;
			_pendingRecentPlayersRequestId = 0L;
			_recentPlayersRequestInProgress = false;
			_hasDeferredRecentPlayersSnapshot = false;
			_deferredRecentPlayersSnapshot = default(WardRecentPlayersSnapshot);
			_recentPlayersListState = RecentPlayersListState.None;
			if (_recentPlayersStatusRow != null)
			{
				Object.Destroy((Object)(object)_recentPlayersStatusRow.Root);
				_recentPlayersStatusRow = null;
			}
		}

		private void BuildRestrictions()
		{
			//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_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_0036: 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_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_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_0095: 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_0143: 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_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Expected O, but got Unknown
			GUIManager instance = GUIManager.Instance;
			Vector2 restrictionListSize = WardGuiLayoutSettings.GetRestrictionListSize();
			CreateLabel(WardLocalization.Localize("$stuw_ui_restrictions", "Restrictions"), WardGuiLayoutSettings.GetRestrictionsHeaderPosition(), 24, restrictionListSize.x, 40f, (TextAnchor)4, instance.AveriaSerifBold, instance.ValheimOrange);
			GameObject val = instance.CreateScrollView(_restrictionsPageRoot.transform, false, true, 20f, 6f, instance.ValheimScrollbarHandleColorBlock, new Color(0f, 0f, 0f, 0.35f), restrictionListSize.x, restrictionListSize.y);
			ConfigureRect(val.GetComponent<RectTransform>(), WardGuiLayoutSettings.GetRestrictionListPosition(), restrictionListSize.x, restrictionListSize.y);
			((Object)val).name = "STUWardRestrictions";
			ref RectTransform? restrictionsContent = ref _restrictionsContent;
			Transform obj = val.transform.Find("Scroll View/Viewport/Content");
			restrictionsContent = (RectTransform?)(object)((obj is RectTransform) ? obj : null);
			if ((Object)(object)_restrictionsContent == (Object)null)
			{
				return;
			}
			VerticalLayoutGroup component = ((Component)_restrictionsContent).GetComponent<VerticalLayoutGroup>();
			if ((Object)(object)component != (Object)null)
			{
				((Behaviour)component).enabled = false;
				Object.DestroyImmediate((Object)(object)component);
			}
			GridLayoutGroup val2 = ((Component)_restrictionsContent).gameObject.AddComponent<GridLayoutGroup>();
			if ((Object)(object)val2 == (Object)null)
			{
				Plugin.Log.LogError((object)"Failed to create the ward restrictions grid layout.");
				return;
			}
			val2.startCorner = (Corner)0;
			val2.startAxis = (Axis)1;
			((LayoutGroup)val2).childAlignment = (TextAnchor)0;
			val2.cellSize = WardGuiLayoutSettings.GetRestrictionCellSize();
			val2.spacing = WardGuiLayoutSettings.GetRestrictionCellSpacing();
			((LayoutGroup)val2).padding = new RectOffset(8, 8, 8, 8);
			val2.constraint = (Constraint)1;
			val2.constraintCount = 2;
			IReadOnlyList<WardRestrictionDefinition> restrictionDefinitions = WardSettings.RestrictionDefinitions;
			for (int i = 0; i < restrictionDefinitions.Count; i++)
			{
				WardRestrictionDefinition definition = restrictionDefinitions[i];
				_restrictionRows[definition.Restriction] = CreateRestrictionRow(definition);
			}
		}

		private RestrictionRowView CreateRestrictionRow(WardRestrictionDefinition definition)
		{
			//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_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			//IL_008b: 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_010a: 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_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: 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_017a: 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_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: 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_025b: 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_028d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
			Vector2 restrictionCellSize = WardGuiLayoutSettings.GetRestrictionCellSize();
			float x = restrictionCellSize.x;
			float y = restrictionCellSize.y;
			GameObject val = new GameObject("RestrictionRow", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.transform.SetParent((Transform)(object)_restrictionsContent, false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.SetSizeWithCurrentAnchors((Axis)0, x);
			component.SetSizeWithCurrentAnchors((Axis)1, y);
			((Graphic)val.GetComponent<Image>()).color = new Color(0f, 0f, 0f, 0.18f);
			Toggle val2 = CreateCenteredToggle(val.transform, new Vector2((0f - x) * 0.5f + 28f, 0f), 30f);
			WardRestrictionOptions restriction = definition.Restriction;
			((UnityEvent<bool>)(object)val2.onValueChanged).AddListener((UnityAction<bool>)delegate(bool enabled)
			{
				OnRestrictionToggleChanged(restriction, enabled);
			});
			GameObject val3 = new GameObject("RestrictionName", new Type[2]
			{
				typeof(RectTransform),
				typeof(Text)
			});
			val3.transform.SetParent(val.transform, false);
			RectTransform component2 = val3.GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(0.5f, 0.5f);
			component2.anchorMax = new Vector2(0.5f, 0.5f);
			component2.pivot = new Vector2(0f, 0.5f);
			component2.anchoredPosition = new Vector2((0f - x) * 0.5f + 58f, 0f);
			component2.SetSizeWithCurrentAnchors((Axis)0, x - 220f);
			component2.SetSizeWithCurrentAnchors((Axis)1, y - 8f);
			Text component3 = val3.GetComponent<Text>();
			GUIManager instance = GUIManager.Instance;
			instance.ApplyTextStyle(component3, instance.AveriaSerifBold, instance.ValheimBeige, 20, false);
			component3.text = WardLocalization.Localize(definition.LocalizationToken, definition.LocalizationFallback);
			component3.alignment = (TextAnchor)3;
			component3.horizontalOverflow = (HorizontalWrapMode)0;
			component3.verticalOverflow = (VerticalWrapMode)0;
			GameObject val4 = new GameObject("RestrictionState", new Type[2]
			{
				typeof(RectTransform),
				typeof(Text)
			});
			val4.transform.SetParent(val.transform, false);
			RectTransform component4 = val4.GetComponent<RectTransform>();
			component4.anchorMin = new Vector2(0.5f, 0.5f);
			component4.anchorMax = new Vector2(0.5f, 0.5f);
			component4.pivot = new Vector2(1f, 0.5f);
			component4.anchoredPosition = new Vector2(x * 0.5f - 14f, 0f);
			component4.SetSizeWithCurrentAnchors((Axis)0, 130f);
			component4.SetSizeWithCurrentAnchors((Axis)1, y - 8f);
			Text component5 = val4.GetComponent<Text>();
			instance.ApplyTextStyle(component5, instance.AveriaSerifBold, instance.ValheimYellow, 18, false);
			component5.alignment = (TextAnchor)5;
			component5.horizontalOverflow = (HorizontalWrapMode)1;
			component5.verticalOverflow = (VerticalWrapMode)0;
			return new RestrictionRowView(val, val2, component3, component5);
		}

		private void RefreshRestrictionRows()
		{
			//IL_0093: 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)
			GUIManager instance = GUIManager.Instance;
			IReadOnlyList<WardRestrictionDefinition> restrictionDefinitions = WardSettings.RestrictionDefinitions;
			for (int i = 0; i < restrictionDefinitions.Count; i++)
			{
				WardRestrictionDefinition wardRestrictionDefinition = restrictionDefinitions[i];
				if (_restrictionRows.TryGetValue(wardRestrictionDefinition.Restriction, out RestrictionRowView value))
				{
					bool flag = WardSettings.IsRestrictionForced(wardRestrictionDefinition.Restriction);
					value.Toggle.isOn = WardSettings.HasRestriction(_currentConfiguration, wardRestrictionDefinition.Restriction);
					((Selectable)value.Toggle).interactable = !flag;
					((Graphic)value.Label).color = (Color)(flag ? new Color(0.65f, 0.62f, 0.55f) : instance.ValheimBeige);
					value.StateText.text = (flag ? WardLocalization.Localize("$stuw_ui_restriction_forced", "Forced") : string.Empty);
				}
			}
		}

		private void OnRestrictionToggleChanged(WardRestrictionOptions restriction, bool enabled)
		{
			if (!_suppressUiEvents)
			{
				if (WardSettings.IsRestrictionForced(restriction))
				{
					RefreshControls();
				}
				else
				{
					ApplyConfigurationDraft(WardSettings.WithRestriction(_currentConfiguration, restriction, enabled));
				}
			}
		}

		private void OnAutoCloseToggleChanged(bool enabled)
		{
			ApplyConfigurationDraft(WardSettings.WithAutoCloseEnabled(_currentConfiguration, enabled));
		}

		private void OnWarningSoundToggleChanged(bool enabled)
		{
			ApplyConfigurationDraft(WardSettings.WithWarningSoundEnabled(_currentConfiguration, enabled));
		}

		private void OnWarningFlashToggleChanged(bool enabled)
		{
			ApplyConfigurationDraft(WardSettings.WithWarningFlashEnabled(_currentConfiguration, enabled));
		}

		private void OnAreaMarkerRotationToggleChanged(bool enabled)
		{
			ApplyConfigurationDraft(WardSettings.WithAreaMarkerRotationEnabled(_currentConfiguration, enabled));
		}

		private void ApplyConfigurationDraft(WardConfiguration configuration)
		{
			if (!_suppressUiEvents)
			{
				_currentConfiguration = configuration;
				RefreshControls();
				ScheduleConfigurationPush();
			}
		}

		private void PushConfiguration()
		{
			if (!((Object)(object)_currentWard == (Object)null))
			{
				WardConfiguration currentConfiguration = _currentConfiguration;
				_configurationPushPending = false;
				WardConfigurationRequestSubmission wardConfigurationRequestSubmission = WardSettings.RequestUpdateConfiguration(_currentWard, currentConfiguration);
				if (wardConfigurationRequestSubmission.IsPending)
				{
					BeginPendingConfigurationRequest(wardConfigurationRequestSubmission.RequestId, currentConfiguration);
					return;
				}
				WardSettings.ShowConfigurationRequestFeedback(wardConfigurationRequestSubmission.ResultCode);
				ApplyConfigurationResponse(0L, wardConfigurationRequestSubmission.ResultCode, wardConfigurationRequestSubmission.Configuration);
			}
		}

		private void ScheduleConfigurationPush()
		{
			if (!_suppressUiEvents && !((Object)(object)_currentWard == (Object)null))
			{
				_configurationPushPending = true;
				_nextConfigurationPushTime = Time.unscaledTime + 0.15f;
			}
		}

		private void FlushPendingConfigurationPush()
		{
			if (_configurationPushPending)
			{
				PushPendingConfiguration();
			}
		}

		private void PushPendingConfiguration()
		{
			if (!_suppressUiEvents && !((Object)(object)_currentWard == (Object)null) && _configurationPushPending && !HasPendingConfigurationRequest())
			{
				PushConfiguration();
			}
		}

		internal void HandleWardConfigurationResponse(PrivateArea ward, long requestId, WardConfigurationRequestResultCode resultCode, WardConfiguration configuration)
		{
			if (!((Object)(object)_currentWard == (Object)null) && !((Object)(object)ward != (Object)(object)_currentWard))
			{
				ApplyConfigurationResponse(requestId, resultCode, configuration);
			}
		}

		private bool HasPendingConfigurationRequest()
		{
			return _pendingConfigurationRequestId != 0;
		}

		private void BeginPendingConfigurationRequest(long requestId, WardConfiguration submittedConfiguration)
		{
			_pendingConfigurationRequestId = requestId;
			_pendingConfiguration = submittedConfiguration;
			_pendingConfigurationRequestedAt = Time.unscaledTime;
		}

		private void ClearPendingConfigurationRequest()
		{
			_pendingConfigurationRequestId = 0L;
			_pendingConfiguration = default(WardConfiguration);
			_pendingConfigurationRequestedAt = 0f;
		}

		private void ApplyConfigurationResponse(long requestId, WardConfigurationRequestResultCode resultCode, WardConfiguration configuration)
		{
			bool flag = HasPendingConfigurationRequest();
			if (requestId == 0L || (flag && requestId == _pendingConfigurationRequestId))
			{
				bool flag2 = flag && !WardSettings.ConfigurationsMatch(_currentConfiguration, _pendingConfiguration);
				_authoritativeConfiguration = configuration;
				if (flag)
				{
					ClearPendingConfigurationRequest();
				}
				bool flag3 = (uint)(resultCode - 2) <= 2u;
				if (flag3 || !flag2)
				{
					_currentConfiguration = configuration;
				}
				if (flag3)
				{
					_configurationPushPending = false;
				}
				RefreshControls();
				TryFlushDeferredConfigurationAfterRequestResolution();
			}
		}

		private void RefreshAuthoritativeConfigurationFromWard()
		{
			if ((Object)(object)_currentWard == (Object)null)
			{
				return;
			}
			WardConfiguration configuration = WardSettings.GetConfiguration(_currentWard);
			if (!WardSettings.ConfigurationsMatch(_authoritativeConfiguration, configuration))
			{
				_authoritativeConfiguration = configuration;
				if (!_configurationPushPending && !WardSettings.ConfigurationsMatch(_currentConfiguration, configuration))
				{
					_currentConfiguration = configuration;
					RefreshControls();
				}
			}
		}

		private void HandlePendingConfigurationRequestTimeout()
		{
			if (!((Object)(object)_currentWard == (Object)null) && HasPendingConfigurationRequest())
			{
				Plugin.Log.LogWarning((object)$"Timed out waiting for ward configuration response for ward instanceId={((Object)_currentWard).GetInstanceID()} requestId={_pendingConfigurationRequestId}.");
				bool num = !WardSettings.ConfigurationsMatch(_currentConfiguration, _pendingConfiguration);
				_authoritativeConfiguration = WardSettings.GetConfiguration(_currentWard);
				ClearPendingConfigurationRequest();
				if (!num)
				{
					_currentConfiguration = _authoritativeConfiguration;
					RefreshControls();
				}
				TryFlushDeferredConfigurationAfterRequestResolution();
			}
		}

		private void TryFlushDeferredConfigurationAfterRequestResolution()
		{
			if (!HasPendingConfigurationRequest())
			{
				if (_configurationPushPending && (_closeRequested || Time.unscaledTime >= _nextConfigurationPushTime))
				{
					PushPendingConfiguration();
				}
				if (_closeRequested && !HasPendingConfigurationRequest() && !_configurationPushPending)
				{
					CompleteCloseWardUi();
				}
			}
		}

		private GameObject CreatePageRoot(string name, Vector2 panelSize)
		{
			//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_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)
			//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_004d: Expected O, but got Unknown
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(_panel.transform, false);
			ConfigureRect(val.GetComponent<RectTransform>(), Vector2.zero, panelSize.x, panelSize.y);
			return val;
		}

		private Transform GetBuildParent()
		{
			if (!((Object)(object)_buildParent != (Object)null))
			{
				return _panel.transform;
			}
			return _buildParent;
		}

		private Button CreateButton(string text, Vector2 position, float width, float height)
		{
			//IL_001b: 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_002f: Unknown result type (might be due to invalid IL or missing references)
			return GUIManager.Instance.CreateButton(text, _panel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), position, width, height).GetComponent<Button>();
		}

		private Button CreateAnchoredButton(Transform parent, string text, Vector2 position, float width, float height)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			return GUIManager.Instance.CreateButton(text, parent, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), position, width, height).GetComponent<Button>();
		}

		private Toggle CreateCenteredToggle(Transform parent, Vector2 position, float boxSize)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return CreateAnchoredToggle(parent, position, boxSize, centerGraphic: true);
		}

		private Toggle CreateAnchoredToggle(Transform parent, Vector2 position, float boxSize, bool centerGraphic = false, float graphicYOffset = 0f)
		{
			//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_002d: 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_00a5: 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_00d1: 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_0101: 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_01c4: 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_018e: 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)
			GameObject obj = DefaultControls.CreateToggle(default(Resources));
			obj.transform.SetParent(parent, false);
			((Object)obj).name = "STUWardToggle";
			ConfigureRect(obj.GetComponent<RectTransform>(), position, boxSize, boxSize);
			Toggle component = obj.GetComponent<Toggle>();
			Transform obj2 = obj.transform.Find("Background");
			Image val = ((obj2 != null) ? ((Component)obj2).GetComponent<Image>() : null);
			if ((Object)(object)val != (Object)null)
			{
				((Graphic)val).color = new Color(0f, 0f, 0f, 0.6f);
				Transform transform = ((Component)val).transform;
				RectTransform val2 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
				if (val2 != null)
				{
					if (centerGraphic)
					{
						val2.anchorMin = new Vector2(0.5f, 0.5f);
						val2.anchorMax = new Vector2(0.5f, 0.5f);
						val2.pivot = new Vector2(0.5f, 0.5f);
					}
					val2.SetSizeWithCurrentAnchors((Axis)0, boxSize);
					val2.SetSizeWithCurrentAnchors((Axis)1, boxSize);
					val2.anchoredPosition = (Vector2)(centerGraphic ? new Vector2(0f, graphicYOffset) : Vector2.zero);
				}
			}
			Transform obj3 = obj.transform.Find("Background/Checkmark");
			Image val3 = ((obj3 != null) ? ((Component)obj3).GetComponent<Image>() : null);
			if ((Object)(object)val3 != (Object)null)
			{
				((Graphic)val3).color = GUIManager.Instance.ValheimOrange;
				Transform transform2 = ((Component)val3).transform;
				RectTransform val4 = (RectTransform)(object)((transform2 is RectTransform) ? transform2 : null);
				if (val4 != null)
				{
					float num = Mathf.Max(4f, boxSize - 6f);
					if (centerGraphic)
					{
						val4.anchorMin = new Vector2(0.5f, 0.5f);
						val4.anchorMax = new Vector2(0.5f, 0.5f);
						val4.pivot = new Vector2(0.5f, 0.5f);
					}
					val4.SetSizeWithCurrentAnchors((Axis)0, num);
					val4.SetSizeWithCurrentAnchors((Axis)1, num);
					val4.anchoredPosition = Vector2.zero;
				}
			}
			Transform val5 = obj.transform.Find("Label");
			if ((Object)(object)val5 != (Object)null)
			{
				((Component)val5).gameObject.SetActive(false);
			}
			return component;
		}

		private Text CreateLabel(string text, Vector2 position, int fontSize, float width, float height, TextAnchor alignment, Font font, Color color)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: 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_0046: Unknown result type (might be due to invalid IL or missing references)
			Text component = GUIManager.Instance.CreateText(text, GetBuildParent(), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), position, font, fontSize, color, true, Color.black, width, height, false).GetComponent<Text>();
			component.alignment = alignment;
			return component;
		}

		private void CreatePlayerSearchInput(Vector2 position, string query, Action<string> onValueChanged, string objectName)
		{
			//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_002d: 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_0054: 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)
			Vector2 playerSearchSize = WardGuiLayoutSettings.GetPlayerSearchSize();
			GameObject obj = GUIManager.Instance.CreateInputField(_generalPageRoot.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), position, (ContentType)0, WardLocalization.Localize("$stuw_ui_search_players", "Search players..."), 18, playerSearchSize.x, playerSearchSize.y);
			((Object)obj).name = objectName;
			InputField component = obj.GetComponent<InputField>();
			component.lineType = (LineType)0;
			component.text = query;
			((UnityEvent<string>)(object)component.onValueChanged).AddListener((UnityAction<string>)delegate(string value)
			{
				onValueChanged(value);
			});
		}

		private void SetActivePage(WardSettingsPage page)
		{
			bool num = page == WardSettingsPage.General && _currentPage != WardSettingsPage.General;
			_currentPage = page;
			if ((Object)(object)_generalPageRoot != (Object)null)
			{
				_generalPageRoot.SetActive(page == WardSettingsPage.General);
			}
			if ((Object)(object)_restrictionsPageRoot != (Object)null)
			{
				_restrictionsPageRoot.SetActive(page == WardSettingsPage.Restrictions);
			}
			if ((Object)(object)_previousPageButton != (Object)null)
			{
				((Component)_previousPageButton).gameObject.SetActive(page == WardSettingsPage.Restrictions);
			}
			if ((Object)(object)_nextPageButton != (Object)null)
			{
				((Component)_nextPageButton).gameObject.SetActive(page == WardSettingsPage.General);
			}
			if (num && _visible && (Object)(object)_currentWard != (Object)null)
			{
				RequestRecentPlayersSnapshot();
			}
		}

		private static void StylePageArrowButton(Button? button)
		{
			//IL_003c: 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_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)
			Text val = (((Object)(object)button != (Object)null) ? ((Component)button).GetComponentInChildren<Text>() : null);
			if (!((Object)(object)val == (Object)null))
			{
				val.text = val.text.Trim();
				val.fontSize = 34;
				((Graphic)val).color = GUIManager.Instance.ValheimYellow;
				val.alignment = (TextAnchor)4;
				RectTransform rectTransform = ((Graphic)val).rectTransform;
				rectTransform.anchoredPosition += new Vector2(0f, 1f);
			}
		}

		private static void ConfigureRect(RectTransform? rectTransform, Vector2 position, float width, float height)
		{
			//IL_0015: 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_003f: 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)
			if (!((Object)(object)rectTransform == (Object)null))
			{
				rectTransform.anchorMin = new Vector2(0.5f, 0.5f);
				rectTransform.anchorMax = new Vector2(0.5f, 0.5f);
				rectTransform.pivot = new Vector2(0.5f, 0.5f);
				rectTransform.anchoredPosition = position;
				rectTransform.SetSizeWithCurrentAnchors((Axis)0, width);
				rectTransform.SetSizeWithCurrentAnchors((Axis)1, height);
			}
		}

		private static string BuildPlayerDisplayText(string playerName, string guildName, string accountId)
		{
			string text = (string.IsNullOrWhiteSpace(guildName) ? "-" : guildName);
			string text2 = (string.IsNullOrWhiteSpace(accountId) ? "-" : accountId);
			return WardLocalization.LocalizeFormat("$stuw_ui_registered_player_format", "{0} / {1} / {2}", playerName, text, text2);
		}

		private static string BuildPlayerSearchText(string playerName, string guildName, string accountId, long playerId)
		{
			return $"{playerName}\n{guildName}\n{accountId}\n{playerId}";
		}

		private static bool MatchesPlayerSearch(string searchText, string query)
		{
			if (query.Length != 0)
			{
				return searchText.IndexOf(query, StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}

		private static void GetPermittedPlayerIdentity(PrivateArea? area, long playerId, out string guildName, out string accountId)
		{
			if (!WardPermittedSnapshots.TryGet(area, playerId, out guildName, out accountId))
			{
				guildName = GuildsCompat.GetPlayerGuildName(playerId);
				accountId = WardOwnership.GetPlayerSteamIdDisplay(playerId);
			}
		}
	}
	internal static class WardGuiLayoutSettings
	{
		internal static Vector2 GetPanelOffset()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(0f, 0f);
		}

		internal static Vector2 GetPanelSize()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(1080f, 900f);
		}

		internal static Vector2 GetTitlePosition()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(0f, 400f);
		}

		internal static Vector2 GetTitleSize()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(300f, 56f);
		}

		internal static Vector2 GetOwnerPosition()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(-340f, 400f);
		}

		internal static Vector2 GetGuildPosition()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(-340f, 362f);
		}

		internal static Vector2 GetOwnerGuildLabelSize()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(360f, 34f);
		}

		internal static Vector2 GetCloseButtonPosition()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(440f, 400f);
		}

		internal static Vector2 GetPageArrowButtonPosition()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(315f, 400f);
		}

		internal static float GetBehaviorToggleSize()
		{
			return 30f;
		}

		internal static Vector2 GetBehaviorControlsGridPosition()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(-15f, 245f);
		}

		internal static Vector2 GetBehaviorControlsGridSize()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(960f, 118f);
		}

		internal static Vector2 GetRegisteredPlayersRemoveButtonPosition()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(395f, 0f);
		}

		internal static Vector2 GetPlayerListHeaderLabelSize()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(630f, 40f);
		}

		internal static Vector2 GetPlayerSearchSize()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(280f, 36f);
		}

		internal static Vector2 GetRegisteredPlayersHeaderPosition()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(-180f, 315f);
		}

		internal static Vector2 GetRegisteredPlayersSearchPosition()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(325f, 315f);
		}

		internal static Vector2 GetPermittedListPosition()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(-15f, 145f);
		}

		internal static Vector2 GetPermittedListSize()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(960f, 280f);
		}

		internal static Vector2 GetRecentPlayersHeaderPosition()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(-180f, -30f);
		}

		internal static Vector2 GetRecentPlayersSearchPosition()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(325f, -30f);
		}

		internal static Vector2 GetRecentPlayersListPosition()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(-15f, -230f);
		}

		internal static Vector2 GetRecentPlayersListSize()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(960f, 340f);
		}

		internal static Vector2 GetRestrictionsHeaderPosition()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(0f, 150f);
		}

		internal static Vector2 GetRestrictionListPosition()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(-15f, -133f);
		}

		internal static Vector2 GetRestrictionListSize()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(960f, 504f);
		}

		internal static Vector2 GetRestrictionCellSize()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(452f, 48f);
		}

		internal static Vector2 GetRestrictionCellSpacing()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(8f, 6f);
		}
	}
	internal static class WardOwnership
	{
		private sealed class IdentityAuthState
		{
			internal readonly Dictionary<long, string> ServerPlayerAccountIdsByPlayerId = new Dictionary<long, string>();

			internal readonly Dictionary<long, ServerSessionIdentity> ServerSessionIdentitiesBySender = new Dictionary<long, ServerSessionIdentity>();
		}

		private readonly struct ManagedWardScanEntry
		{
			internal long OwnerPlayerId { get; }

			internal string AccountId { get; }

			internal ManagedWardScanEntry(long ownerPlayerId, string accountId)
			{
				OwnerPlayerId = ownerPlayerId;
				AccountId = accountId ?? string.Empty;
			}
		}

		private const string ManagedWardMarkerKey = "stuw_is_managed_ward";

		internal const string SteamAccountIdKey = "stuw_owner_account_id";

		private const string LimitRefundProcessedKey = "stuw_limit_refund_processed";

		private const string ReceiveWardPlacementRejectedRpc = "STUWard_ReceiveWardPlacementRejected";

		private const string NotifyManagedWardPlacedRpc = "STUWard_NotifyManagedWardPlaced";

		private const string NotifyManagedWardMapStateChangedRpc = "STUWard_NotifyManagedWardMapStateChanged";

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

		private static readonly HashSet<ZDOID> AcceptedManagedWardIds = new HashSet<ZDOID>();

		private static readonly int ManagedWardPrefabHash = StringExtensionMethods.GetStableHashCode("piece_stuward");

		private static ZDOMan? _trackedZdoMan;

		private static bool _managedWardObservationInitialized;

		private static bool _rpcsRegistered;

		private const int MaxPendingManagedWardPlacementObserves = 512;

		private const int MaxPendingManagedWardPlacementObservesPerRequester = 32;

		private const uint MaxPendingMapStateRevisionLead = 128u;

		private static readonly TimeSpan MinimumManagedWardPlacementObserveInterval = TimeSpan.FromMilliseconds(250.0);

		private static readonly TimeSpan PendingManagedWardPlacementObserveLifetime = TimeSpan.FromSeconds(10.0);

		private static readonly TimeSpan PendingManagedWardMapStateRefreshLifetime = TimeSpan.FromSeconds(10.0);

		private static readonly Dictionary<long, DateTime> LastManagedWardPlacementObserveUtcByRequesterId = new Dictionary<long, DateTime>();

		private static readonly Dictionary<(ZDOID WardZdoId, long RequesterId), PendingManagedWardPlacementObserve> PendingManagedWardPlacementObserves = new Dictionary<(ZDOID, long), PendingManagedWardPlacementObserve>();

		private static readonly Dictionary<ZDOID, PendingManagedWardMapStateRefresh> PendingManagedWardMapStateRefreshes = new Dictionary<ZDOID, PendingManagedWardMapStateRefresh>();

		private static readonly IdentityAuthState IdentityAuthData = new IdentityAuthState();

		private const string ReportFileName = "STUWard.WardCountReport.yml";

		private static Dictionary<long, string> ServerPlayerAccountIdsByPlayerId => IdentityAuthData.ServerPlayerAccountIdsByPlayerId;

		private static Dictionary<long, ServerSessionIdentity> ServerSessionIdentitiesBySender => IdentityAuthData.ServerSessionIdentitiesBySender;

		internal static void Update()
		{
			EnsureManagedWardObservationInitialized();
			ProcessPendingManagedWardPlacementObserves();
			ProcessPendingManagedWardMapStateRefreshes();
		}

		internal static bool HasPendingRuntimeWork()
		{
			if ((!((Object)(object)ZNet.instance != (Object)null) || !ZNet.instance.IsServer() || _managedWardObservationInitialized) && PendingManagedWardPlacementObserves.Count <= 0)
			{
				return PendingManagedWardMapStateRefreshes.Count > 0;
			}
			return true;
		}

		internal static void RegisterRpcs()
		{
			ZRoutedRpc instance = ZRoutedRpc.instance;
			if (!_rpcsRegistered && instance != null)
			{
				instance.Register<ZPackage>("STUWard_ReceiveWardPlacementRejected", (Action<long, ZPackage>)HandleReceiveWardPlacementRejected);
				instance.Register<ZPackage>("STUWard_NotifyManagedWardPlaced", (Action<long, ZPackage>)HandleNotifyManagedWardPlaced);
				instance.Register<ZPackage>("STUWard_NotifyManagedWardMapStateChanged", (Action<long, ZPackage>)HandleNotifyManagedWardMapStateChanged);
				_rpcsRegistered = true;
			}
		}

		internal static void ResetRuntimeState()
		{
			_rpcsRegistered = false;
			ResetServerRuntimeState();
		}

		internal static void ObserveManagedWard(ManagedWardRef ward)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ward.Area == (Object)null || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			ZDO zdo = ward.Zdo;
			if (zdo != null)
			{
				EnsureManagedWardObservationInitialized();
				PromoteRuntimeManagedWardZdo(zdo);
				if (_managedWardObservationInitialized && !AcceptedManagedWardIds.Contains(zdo.m_uid))
				{
					ObserveAuthoritativeManagedWardPlacement(zdo);
				}
				else
				{
					ObserveManagedWard(zdo);
				}
			}
		}

		internal static bool TryStampLocalManagedWardOwnerAccount(PrivateArea? area)
		{
			return TryStampLocalManagedWardOwnerAccount(ManagedWardRef.FromArea(area));
		}

		internal static bool TryStampLocalManagedWardOwnerAccount(ManagedWardRef ward)
		{
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ward.Area == (Object)null || !ManagedWardIdentity.EnsureManagedComponent(ward))
			{
				return false;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return false;
			}
			if (!WardAccess.IsDirectWardOwner(ward, localPlayer.GetPlayerID()))
			{
				return false;
			}
			string playerAccountId = GetPlayerAccountId(localPlayer);
			if (string.IsNullOrWhiteSpace(playerAccountId))
			{
				return false;
			}
			if (!ward.HasValidNetworkIdentity || !ward.IsOwner)
			{
				return false;
			}
			ZDO zdo = ward.Zdo;
			if (zdo == null)
			{
				return false;
			}
			bool flag = false;
			if (!zdo.GetBool("stuw_is_managed_ward", false))
			{
				zdo.Set("stuw_is_managed_ward", true);
				flag = true;
			}
			ManagedWardProjection projection = ManagedWardProjectionService.ResolveExplicitProjection(localPlayer.GetPlayerID(), playerAccountId, GuildsCompat.GetPlayerGuildIdentity(localPlayer));
			if (!(flag | ManagedWardProjectionService.ApplyOwnedLocalProjection(zdo, projection, forceSendWhenMetadataChanged: false).AnyChanged))
			{
				return false;
			}
			ZDOMan instance = ZDOMan.instance;
			if (instance != null)
			{
				instance.ForceSendZDO(zdo.m_uid);
			}
			return true;
		}

		internal static void RefreshServerPlayerAccountIdForPlayer(Player? player)
		{
			if (!((Object)(object)player == (Object)null) && !((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer())
			{
				string playerAccountId = GetPlayerAccountId(player);
				if (!string.IsNullOrWhiteSpace(playerAccountId))
				{
					RememberServerPlayerAccountId(player.GetPlayerID(), playerAccountId);
				}
			}
		}

		internal static void RefreshServerPlayerAccountIdForResolvedPlayer(long playerId, string accountId)
		{
			RememberServerPlayerAccountId(playerId, accountId);
		}

		private static void SendWardPlacementRejectedResponse(long receiverUid, int limit, bool showLimitMessage)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			ZRoutedRpc instance = ZRoutedRpc.instance;
			if (instance == null)
			{
				return;
			}
			if (IsLocalReceiver(receiverUid))
			{
				ManagedWardMapStateService.RequestLocalDisplayRefresh(refreshImmediatelyIfVisible: true);
				if (showLimitMessage)
				{
					WardAccess.ShowWardLimitMessage(Player.m_localPlayer, limit);
				}
			}
			else
			{
				ZPackage val = new ZPackage();
				val.Write(showLimitMessage);
				val.Write(limit);
				instance.InvokeRoutedRPC(receiverUid, "STUWard_ReceiveWardPlacementRejected", new object[1] { val });
			}
		}

		private static void RejectManagedWardPlacement(ZDO? zdo, long receiverUid, int limit, bool showLimitMessage)
		{
			//IL_001a: 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)
			SendWardPlacementRejectedResponse(receiverUid, limit, showLimitMessage);
			if (zdo == null || !zdo.IsValid())
			{
				return;
			}
			DropManagedWardPlacementRefundOnce(zdo);
			ForgetManagedWardRuntimeState(zdo.m_uid);
			TryClaimManagedWardMutationOwnership(zdo);
			ZNetScene instance = ZNetScene.instance;
			GameObject val = ((instance != null) ? instance.FindInstance(zdo.m_uid) : null);
			if ((Object)(object)val != (Object)null && (Object)(object)ZNetScene.instance != (Object)null)
			{
				ZNetScene.instance.Destroy(val);
				return;
			}
			ZDOMan instance2 = ZDOMan.instance;
			if (instance2 != null)
			{
				instance2.DestroyZDO(zdo);
			}
		}

		private static void DropManagedWardPlacementRefundOnce(ZDO zdo)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if (zdo != null && zdo.IsValid() && !zdo.GetBool("stuw_limit_refund_processed", false))
			{
				zdo.Set("stuw_limit_refund_processed", true);
				DropManagedWardPlacementRefund(zdo.GetPosition());
			}
		}

		private static void DropManagedWardPlacementRefund(Vector3 position)
		{
			//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)
			//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_00ab: 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)
			Requirement[] currentStuWardRequirements = StuWardPrefab.GetCurrentStuWardRequirements();
			if (currentStuWardRequirements.Length == 0)
			{
				return;
			}
			Vector3 val = position + Vector3.up;
			foreach (Requirement val2 in currentStuWardRequirements)
			{
				ItemDrop resItem = val2.m_resItem;
				if ((Object)(object)resItem == (Object)null || !val2.m_recover)
				{
					continue;
				}
				int amount = val2.GetAmount(1);
				if (amount > 0)
				{
					GameObject gameObject = ((Component)resItem).gameObject;
					int val3 = Math.Max(1, resItem.m_itemData.m_shared.m_maxStackSize);
					int num = amount;
					while (num > 0)
					{
						int num2 = Math.Min(num, val3);
						num -= num2;
						ItemData obj = resItem.m_itemData.Clone();
						obj.m_dropPrefab = gameObject;
						obj.m_stack = num2;
						ItemDrop.DropItem(obj, num2, val, Quaternion.Euler(0f, Random.Range(0f, 360f), 0f));
					}
				}
			}
		}

		private static bool IsLocalReceiver(long receiverUid)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null && receiverUid != 0L)
			{
				return ((Character)localPlayer).GetOwner() == receiverUid;
			}
			return false;
		}

		private static void HandleReceiveWardPlacementRejected(long sender, ZPackage pkg)
		{
			if (IsAuthoritativeServerSender(sender) && pkg != null)
			{
				bool flag;
				int limit;
				try
				{
					flag = pkg.ReadBool();
					limit = pkg.ReadInt();
				}
				catch
				{
					return;
				}
				ManagedWardMapStateService.RequestDisplayRefresh(liveDisplayRefresh: true);
				if (flag)
				{
					WardAccess.ShowWardLimitMessage(Player.m_localPlayer, limit);
				}
			}
		}

		private static int GetEffectiveWardLimitForAccount(string accountId)
		{
			return WardLimitPolicy.GetEffectiveLimit(NormalizeAccountId(accountId), ManagedWardConfigFileService.CurrentSnapshot.WardLimitOverrides, Plugin.MaxWardsPerSteamId?.Value ?? 3);
		}

		private static void ResetServerRuntimeState()
		{
			ResetPlacementLifecycleState();
			ManagedWardRegistry.Reset();
			ResetIdentityAuthState();
		}

		private static void ResetPlacementLifecycleState()
		{
			if (_trackedZdoMan != null)
			{
				ZDOMan? trackedZdoMan = _trackedZdoMan;
				trackedZdoMan.m_onZDODestroyed = (Action<ZDO>)Delegate.Remove(trackedZdoMan.m_onZDODestroyed, new Action<ZDO>(HandleTrackedWardDestroyed));
				_trackedZdoMan = null;
			}
			LastManagedWardPlacementObserveUtcByRequesterId.Clear();
			PendingManagedWardPlacementObserves.Clear();
			PendingManagedWardMapStateRefreshes.Clear();
			AcceptedManagedWardIds.Clear();
			_managedWardObservationInitialized = false;
		}

		private static void EnsureManagedWardObservationInitialized()
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			ZDOMan instance = ZDOMan.instance;
			if (instance != null)
			{
				EnsureTrackedZdoManHooked(instance);
				if (!_managedWardObservationInitialized)
				{
					RunInitialManagedWardObservationPass(instance);
				}
			}
		}

		private static void EnsureTrackedZdoManHooked(ZDOMan zdoMan)
		{
			if (_trackedZdoMan != zdoMan)
			{
				if (_trackedZdoMan != null)
				{
					ZDOMan? trackedZdoMan = _trackedZdoMan;
					trackedZdoMan.m_onZDODestroyed = (Action<ZDO>)Delegate.Remove(trackedZdoMan.m_onZDODestroyed, new Action<ZDO>(HandleTrackedWardDestroyed));
				}
				zdoMan.m_onZDODestroyed = (Action<ZDO>)Delegate.Combine(zdoMan.m_onZDODestroyed, new Action<ZDO>(HandleTrackedWardDestroyed));
				_trackedZdoMan = zdoMan;
			}
		}

		private static void RunInitialManagedWardObservationPass(ZDOMan zdoMan)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			EnsureTrackedZdoManHooked(zdoMan);
			_managedWardObservationInitialized = false;
			ManagedWardRegistry.Reset();
			AcceptedManagedWardIds.Clear();
			int num = PrepareManagedWardPrefabScan(zdoMan);
			for (int i = 0; i < num; i++)
			{
				ZDO val = ManagedWardPrefabScanBuffer[i];
				if (IsManagedWardZdo(val) && !val.GetBool("stuw_limit_refund_processed", false))
				{
					AcceptedManagedWardIds.Add(val.m_uid);
				}
				ObserveManagedWard(val);
			}
			_managedWardObservationInitialized = true;
			WardSettings.ClampStoredRadiiToServerMaximum();
		}

		internal static void OnAuthoritativeWorldZdosLoaded(ZDOMan zdoMan)
		{
			if (zdoMan != null && !((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer())
			{
				RunInitialManagedWardObservationPass(zdoMan);
			}
		}

		private static int PrepareManagedWardPrefabScan(ZDOMan zdoMan)
		{
			ManagedWardPrefabScanBuffer.Clear();
			int num = 0;
			while (!zdoMan.GetAllZDOsWithPrefabIterative("piece_stuward", ManagedWardPrefabScanBuffer, ref num))
			{
			}
			return ManagedWardPrefabScanBuffer.Count;
		}

		private static void ObserveManagedWard(ZDO? zdo)
		{
			if (IsManagedWardZdo(zdo))
			{
				long num = zdo.GetLong(ZDOVars.s_creator, 0L);
				bool authoritativeMetadataChanged = false;
				if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
				{
					authoritativeMetadataChanged = TryCanonicalizeWardSteamAccountIdFromCreator(zdo, num);
				}
				string wardSteamAccountId = ResolveWardSteamAccountId(zdo, num);
				ManagedWardProjectionService.ObserveAuthoritativeWard(zdo, num, wardSteamAccountId, authoritativeMetadataChanged);
			}
		}

		private static void ObserveAuthoritativeManagedWardPlacement(ZDO? zdo)
		{
			//IL_0016: 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)
			EnsureManagedWardObservationInitialized();
			if (IsManagedWardZdo(zdo))
			{
				bool metadataChanged;
				if (AcceptedManagedWardIds.Contains(zdo.m_uid))
				{
					ObserveManagedWard(zdo);
				}
				else if (TryFinalizeAuthoritativeManagedWardPlacement(zdo, out metadataChanged))
				{
					AcceptedManagedWardIds.Add(zdo.m_uid);
					long num = zdo.GetLong(ZDOVars.s_creator, 0L);
					string wardSteamAccountId = ResolveWardSteamAccountId(zdo, num);
					ManagedWardProjectionService.ObserveAuthoritativeWard(zdo, num, wardSteamAccountId, metadataChanged);
					RefreshFinalizedManagedWardRuntime(zdo);
				}
			}
		}

		internal static bool IsAcceptedManagedWard(ZDO? zdo)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if (zdo != null && zdo.IsValid() && !zdo.GetBool("stuw_limit_refund_processed", false))
			{
				return AcceptedManagedWardIds.Contains(zdo.m_uid);
			}
			return false;
		}

		private static void RefreshFinalizedManagedWardRuntime(ZDO zdo)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			ZNetScene instance = ZNetScene.instance;
			GameObject val = ((instance != null) ? instance.FindInstance(zdo.m_uid) : null);
			PrivateArea val2 = (((Object)(object)val != (Object)null) ? (val.GetComponent<PrivateArea>() ?? val.GetComponentInChildren<PrivateArea>()) : null);
			if (!((Object)(object)val2 == (Object)null))
			{
				ManagedWardRef ward = ManagedWardRef.FromArea(val2, zdo);
				WardAccess.RegisterManagedWard(ward);
				WardSettings.ApplyAreaState(ward);
				val2.UpdateStatus();
			}
		}

		private static bool TryCanonicalizeWardSteamAccountIdFromCreator(ZDO zdo, long ownerPlayerId)
		{
			if (zdo == null || ownerPlayerId == 0L || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return false;
			}
			string playerAccountId = GetPlayerAccountId(ownerPlayerId);
			if (string.IsNullOrWhiteSpace(playerAccountId))
			{
				return false;
			}
			if (SameAccountId(NormalizeAccountId(zdo.GetString("stuw_owner_account_id", string.Empty)), playerAccountId))
			{
				return false;
			}
			zdo.Set("stuw_owner_account_id", playerAccountId);
			return true;
		}

		private static bool TryFinalizeAuthoritativeManagedWardPlacement(ZDO zdo, out bool metadataChanged)
		{
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			metadataChanged = false;
			if (!IsManagedWardZdo(zdo))
			{
				return false;
			}
			string left = NormalizeAccountId(zdo.GetString("stuw_owner_account_id", string.Empty));
			long num = zdo.GetLong(ZDOVars.s_creator, 0L);
			long owner = zdo.GetOwner();
			long senderUid;
			long num2 = ((num != 0L && TryGetServerSessionSenderUid(num, out senderUid)) ? senderUid : owner);
			long num3 = ((owner != 0L && owner != ZDOMan.GetSessionID()) ? ResolvePlayerIdFromSender(owner) : 0);
			if (num != 0L && owner != 0L && owner != ZDOMan.GetSessionID() && num3 != 0L && num3 != num)
			{
				RejectManagedWardPlacement(zdo, owner, 0, showLimitMessage: false);
				return false;
			}
			string authoritativeAccountIdFromSender = GetAuthoritativeAccountIdFromSender(num2, num);
			if (string.IsNullOrWhiteSpace(authoritativeAccountIdFromSender))
			{
				RejectManagedWardPlacement(zdo, num2, 0, showLimitMessage: false);
				return false;
			}
			int effectiveWardLimitForAccount = GetEffectiveWardLimitForAccount(authoritativeAccountIdFromSender);
			if (!TryCountAuthoritativeManagedWardsForAccount(authoritativeAccountIdFromSender, num, zdo.m_uid, out var count))
			{
				RejectManagedWardPlacement(zdo, num2, 0, showLimitMessage: false);
				return false;
			}
			if (!WardLimitPolicy.CanPlaceWard(effectiveWardLimitForAccount, count))
			{
				RejectManagedWardPlacement(zdo, num2, effectiveWardLimitForAccount, showLimitMessage: true);
				return false;
			}
			if (!TryClaimManagedWardMutationOwnership(zdo))
			{
				RejectManagedWardPlacement(zdo, num2, 0, showLimitMessage: false);
				return false;
			}
			if (!SameAccountId(left, authoritativeAccountIdFromSender))
			{
				zdo.Set("stuw_owner_account_id", authoritativeAccountIdFromSender);
				metadataChanged = true;
			}
			ManagedWardProjection projection = ManagedWardProjectionService.ResolveProjection(zdo, num, authoritativeAccountIdFromSender);
			if (!projection.HasResolvedGuild)
			{
				projection = new ManagedWardProjection(authoritativeAccountIdFromSender, hasResolvedGuild: true, default(WardGuildIdentity));
			}
			metadataChanged |= ManagedWardProjectionService.ApplyProjection(zdo, projection).AnyChanged;
			if (!WardSettings.TryAssignAuthoritativePlacementRadius(zdo, out var _))
			{
				RejectManagedWardPlacement(zdo, num2, 0, showLimitMessage: false);
				return false;
			}
			metadataChanged = true;
			return true;
		}

		private static bool TryCountAuthoritativeManagedWardsForAccount(string accountId, long ownerPlayerId, ZDOID ignoredZdoId, out int count)
		{
			//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_0073: Unknown result type (might be due to invalid IL or missing references)
			count = 0;
			string text = NormalizeAccountId(accountId);
			ZDOMan instance = ZDOMan.instance;
			if (string.IsNullOrWhiteSpace(text) || instance == null || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return false;
			}
			int num = PrepareManagedWardPrefabScan(instance);
			for (int i = 0; i < num; i++)
			{
				ZDO val = ManagedWardPrefabScanBuffer[i];
				if (IsManagedWardZdo(val) && !(val.m_uid == ignoredZdoId) && AcceptedManagedWardIds.Contains(val.m_uid) && !val.GetBool("stuw_limit_refund_processed", false))
				{
					long num2 = val.GetLong(ZDOVars.s_creator, 0L);
					string text2 = GetPlayerAccountId(num2);
					if (string.IsNullOrWhiteSpace(text2))
					{
						text2 = ResolveWardSteamAccountId(val, num2);
					}
					if (SameAccountId(text2, text) || (string.IsNullOrWhiteSpace(text2) && num2 == ownerPlayerId))
					{
						count++;
					}
				}
			}
			return true;
		}

		private static void HandleTrackedWardDestroyed(ZDO zdo)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			if (zdo != null)
			{
				ForgetManagedWardRuntimeState(zdo.m_uid);
			}
		}

		private static void ForgetManagedWardRuntimeState(ZDOID wardZdoId)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			if (!((ZDOID)(ref wardZdoId)).IsNone())
			{
				ManagedWardRegistry.RemoveEntry(wardZdoId);
				AcceptedManagedWardIds.Remove(wardZdoId);
				WardPrivateAreaSafeAccess.ForgetPermittedPlayerIds(wardZdoId);
				WardPermittedSnapshots.Forget(wardZdoId);
				ManagedWardMapStateService.NotifyWardRemoved(wardZdoId);
			}
		}

		internal static bool IsManagedWardZdo(ZDO? zdo)
		{
			if (zdo == null || !zdo.IsValid())
			{
				return false;
			}
			if (zdo.GetPrefab() == ManagedWardPrefabHash)
			{
				return true;
			}
			if (zdo.GetBool("stuw_is_managed_ward", false))
			{
				return true;
			}
			if (!string.IsNullOrWhiteSpace(NormalizeAccountId(zdo.GetString("stuw_owner_account_id", string.Empty))))
			{
				return true;
			}
			return false;
		}

		private static bool PromoteRuntimeManagedWardZdo(ZDO zdo)
		{
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			if (zdo == null || !zdo.IsValid())
			{
				return false;
			}
			bool flag = false;
			if (!zdo.GetBool("stuw_is_managed_ward", false))
			{
				zdo.Set("stuw_is_managed_ward", true);
				flag = true;
			}
			string playerAccountId = GetPlayerAccountId(zdo.GetLong(ZDOVars.s_creator, 0L));
			string left = NormalizeAccountId(zdo.GetString("stuw_owner_account_id", string.Empty));
			if (!string.IsNullOrWhiteSpace(playerAccountId) && !SameAccountId(left, playerAccountId))
			{
				zdo.Set("stuw_owner_account_id", playerAccountId);
				flag = true;
			}
			if (!flag)
			{
				return false;
			}
			ZDOMan instance = ZDOMan.instance;
			if (instance != null)
			{
				instance.ForceSendZDO(zdo.m_uid);
			}
			return true;
		}

		internal static void ForceSyncManagedWardZdoToServer(ManagedWardRef ward)
		{
			//IL_006e: 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_0087: Expected O, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ward.Area == (Object)null || !ManagedWardIdentity.EnsureManagedComponent(ward) || (Object)(object)ZNet.instance == (Object)null || ZNet.instance.IsServer() || !ward.HasValidNetworkIdentity || !ward.IsOwner)
			{
				return;
			}
			ZDO zdo = ward.Zdo;
			if (zdo != null && zdo.IsValid() && TryGetServerPeerId(out var serverPeerId))
			{
				ZDOMan instance = ZDOMan.instance;
				if (instance != null)
				{
					instance.ForceSendZDO(serverPeerId, zdo.m_uid);
				}
				ZRoutedRpc instance2 = ZRoutedRpc.instance;
				if (instance2 != null)
				{
					ZPackage val = new ZPackage();
					val.Write(zdo.m_uid);
					val.Write(zdo.DataRevision);
					instance2.InvokeRoutedRPC(serverPeerId, "STUWard_NotifyManagedWardMapStateChanged", new object[1] { val });
				}
			}
		}

		internal static bool TryClaimManagedWardMutationOwnership(PrivateArea? area)
		{
			ZNetView nView = WardPrivateAreaSafeAccess.GetNView(area);
			if ((Object)(object)nView == (Object)null || !nView.IsValid())
			{
				return false;
			}
			return TryClaimManagedWardMutationOwnership(WardPrivateAreaSafeAccess.GetZdo(nView));
		}

		internal static bool TryClaimManagedWardMutationOwnership(ZDO? zdo)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			if (zdo == null || !zdo.IsValid())
			{
				return false;
			}
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return true;
			}
			if (zdo.GetOwner() != ZDOMan.GetSessionID())
			{
				zdo.SetOwner(ZDOMan.GetSessionID());
				ZDOMan instance = ZDOMan.instance;
				if (instance != null)
				{
					instance.ForceSendZDO(zdo.m_uid);
				}
			}
			if (zdo.GetOwner() != ZDOMan.GetSessionID())
			{
				return false;
			}
			return true;
		}

		internal static void NotifyServerManagedWardPlaced(ManagedWardRef ward)
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ward.Area == (Object)null || !ManagedWardIdentity.EnsureManagedComponent(ward) || !ward.HasValidNetworkIdentity)
			{
				return;
			}
			ZDO zdo = ward.Zdo;
			if (zdo == null)
			{
				return;
			}
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
			{
				ObserveAuthoritativeManagedWardPlacement(zdo);
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			ZRoutedRpc instance = ZRoutedRpc.instance;
			if (!((Object)(object)localPlayer == (Object)null) && instance != null)
			{
				long serverPeerID = instance.GetServerPeerID();
				if (serverPeerID != 0L)
				{
					ZPackage val = new ZPackage();
					val.Write(localPlayer.GetPlayerID());
					val.Write(zdo.m_uid);
					instance.InvokeRoutedRPC(serverPeerID, "STUWard_NotifyManagedWardPlaced", new object[1] { val });
				}
			}
		}

		internal static bool CanApplyManagedWardStateLocally(ZNetView? nview)
		{
			if ((Object)(object)nview != (Object)null && nview.IsValid() && (Object)(object)ZNet.instance != (Object)null)
			{
				return ZNet.instance.IsServer();
			}
			return false;
		}

		internal static bool TryInvokeServerRoutedRpc(string method, params object[] parameters)
		{
			ZRoutedRpc instance = ZRoutedRpc.instance;
			if (instance == null || string.IsNullOrWhiteSpace(method) || !TryGetServerPeerId(out var serverPeerId))
			{
				return false;
			}
			instance.InvokeRoutedRPC(serverPeerId, method, parameters);
			return true;
		}

		internal static bool TryGetServerPeerId(out long serverPeerId)
		{
			serverPeerId = 0L;
			ZRoutedRpc instance = ZRoutedRpc.instance;
			if (instance == null)
			{
				return false;
			}
			serverPeerId = instance.GetServerPeerID();
			return serverPeerId != 0;
		}

		internal static bool TryResolveAuthoritativeManagedWardRequest(long sender, ZDOID wardZdoId, out ZDO zdo, out long requesterId)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			zdo = null;
			requesterId = 0L;
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || ((ZDOID)(ref wardZdoId)).IsNone() || !TryResolveAuthoritativePlayerIdFromSender(sender, out requesterId))
			{
				return false;
			}
			ZDOMan instance = ZDOMan.instance;
			ZDO val = ((instance != null) ? instance.GetZDO(wardZdoId) : null);
			if (val == null || !val.IsValid() || !IsManagedWardZdo(val))
			{
				return false;
			}
			zdo = val;
			return true;
		}

		internal static void CompleteAuthoritativeManagedWardMutation(ZDO zdo)
		{
			//IL_000c: 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)
			ZDOMan instance = ZDOMan.instance;
			if (instance != null)
			{
				instance.ForceSendZDO(zdo.m_uid);
			}
			ManagedWardMapStateService.NotifyWardMutation(zdo);
			ZNetScene instance2 = ZNetScene.instance;
			GameObject val = ((instance2 != null) ? instance2.FindInstance(zdo.m_uid) : null);
			PrivateArea obj = (((Object)(object)val != (Object)null) ? (val.GetComponent<PrivateArea>() ?? val.GetComponentInChildren<PrivateArea>()) : null);
			if (obj != null)
			{
				obj.UpdateStatus();
			}
		}

		internal static void CompleteAuthoritativePermittedMutation(ZDO zdo)
		{
			WardPermittedSnapshots.Refresh(zdo);
			ManagedWardPresenceService.Invalidate();
			CompleteAuthoritativeManagedWardMutation(zdo);
		}

		private static void HandleNotifyManagedWardPlaced(long sender, ZPackage pkg)
		{
			//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_0056: 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_008c: 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)
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || pkg == null)
			{
				return;
			}
			long claimedPlayerId;
			ZDOID val;
			try
			{
				claimedPlayerId = pkg.ReadLong();
				val = pkg.ReadZDOID();
			}
			catch
			{
				return;
			}
			if (!TryResolveClaimedPlayerIdFromSender(sender, claimedPlayerId, out var playerId) || ((ZDOID)(ref val)).IsNone())
			{
				return;
			}
			ZDOMan instance = ZDOMan.instance;
			ZDO val2 = ((instance != null) ? instance.GetZDO(val) : null);
			if (val2 == null || !val2.IsValid())
			{
				EnqueuePendingManagedWardPlacementObserve(playerId, val);
				return;
			}
			long num = val2.GetLong(ZDOVars.s_creator, 0L);
			if (num == 0L || num == playerId)
			{
				(ZDOID, long) key = (val, playerId);
				if (num == playerId && PendingManagedWardPlacementObserves.TryGetValue(key, out var value))
				{
					PendingManagedWardPlacementObserves[key] = new PendingManagedWardPlacementObserve(value.FirstSeenUtc, isVerified: true);
				}
				else if (!TryBeginManagedWardPlacementObserve(playerId))
				{
					EnqueuePendingManagedWardPlacementObserve(playerId, val, isVerified: true);
				}
				else
				{
					ObserveAuthoritativeManagedWardPlacement(val2);
				}
			}
		}

		private static bool TryBeginManagedWardPlacementObserve(long requesterId)
		{
			DateTime utcNow = DateTime.UtcNow;
			if (LastManagedWardPlacementObserveUtcByRequesterId.TryGetValue(requesterId, out var value) && utcNow >= value && utcNow - value < MinimumManagedWardPlacementObserveInterval)
			{
				return false;
			}
			LastManagedWardPlacementObserveUtcByRequesterId[requesterId] = utcNow;
			return true;
		}

		private static void EnqueuePendingManagedWardPlacementObserve(long requesterId, ZDOID wardZdoId, bool isVerified = false)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			(ZDOID, long) key = (wardZdoId, requesterId);
			if (((ZDOID)(ref wardZdoId)).IsNone() || PendingManagedWardPlacementObserves.ContainsKey(key) || (!isVerified && PendingManagedWardPlacementObserves.Count >= 512))
			{
				return;
			}
			int num = 0;
			foreach (KeyValuePair<(ZDOID, long), PendingManagedWardPlacementObserve> pendingManagedWardPlacementObserf in PendingManagedWardPlacementObserves)
			{
				if (pendingManagedWardPlacementObserf.Key.Item2 == requesterId)
				{
					num++;
					if (num >= 32)
					{
						break;
					}
				}
			}
			bool flag = num >= 32;
			bool flag2 = PendingManagedWardPlacementObserves.Count >= 512;
			if (!(flag || flag2) || (isVerified && TryEvictOldestUnverifiedPlacementObserve(requesterId, flag)))
			{
				PendingManagedWardPlacementObserves.Add(key, new PendingManagedWardPlacementObserve(DateTime.UtcNow, isVerified));
			}
		}

		private static bool TryEvictOldestUnverifiedPlacementObserve(long requesterId, bool requireSameRequester)
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			(ZDOID, long) key = default((ZDOID, long));
			DateTime dateTime = DateTime.MaxValue;
			foreach (KeyValuePair<(ZDOID, long), PendingManagedWardPlacementObserve> pendingManagedWardPlacementObserf in PendingManagedWardPlacementObserves)
			{
				PendingManagedWardPlacementObserve value = pendingManagedWardPlacementObserf.Value;
				if (!value.IsVerified && (!requireSameRequester || pendingManagedWardPlacementObserf.Key.Item2 == requesterId) && !(value.FirstSeenUtc >= dateTime))
				{
					ZDOMan instance = ZDOMan.instance;
					ZDO val = ((instance != null) ? instance.GetZDO(pendingManagedWardPlacementObserf.Key.Item1) : null);
					if (val == null || !val.IsValid() || val.GetLong(ZDOVars.s_creator, 0L) != pendingManagedWardPlacementObserf.Key.Item2)
					{
						flag = true;
						key = pendingManagedWardPlacementObserf.Key;
						dateTime = value.FirstSeenUtc;
					}
				}
			}
			if (flag)
			{
				return PendingManagedWardPlacementObserves.Remove(key);
			}
			return false;
		}

		private static void ProcessPendingManagedWardPlacementObserves()
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			if (PendingManagedWardPlacementObserves.Count == 0 || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			ZDOMan instance = ZDOMan.instance;
			if (instance == null)
			{
				return;
			}
			List<(ZDOID, long)> list = null;
			List<(ZDOID, long)> list2 = null;
			DateTime utcNow = DateTime.UtcNow;
			foreach (KeyValuePair<(ZDOID, long), PendingManagedWardPlacementObserve> pendingManagedWardPlacementObserf in PendingManagedWardPlacementObserves)
			{
				PendingManagedWardPlacementObserve value = pendingManagedWardPlacementObserf.Value;
				ZDO zDO = instance.GetZDO(pendingManagedWardPlacementObserf.Key.Item1);
				if (zDO == null || !zDO.IsValid())
				{
					if (!(utcNow - value.FirstSeenUtc < PendingManagedWardPlacementObserveLifetime))
					{
						if (list == null)
						{
							list = new List<(ZDOID, long)>();
						}
						list.Add(pendingManagedWardPlacementObserf.Key);
					}
					continue;
				}
				long num = zDO.GetLong(ZDOVars.s_creator, 0L);
				if (num != 0L && num != pendingManagedWardPlacementObserf.Key.Item2)
				{
					if (list == null)
					{
						list = new List<(ZDOID, long)>();
					}
					list.Add(pendingManagedWardPlacementObserf.Key);
				}
				else if (!TryBeginManagedWardPlacementObserve(pendingManagedWardPlacementObserf.Key.Item2))
				{
					if (!value.IsVerified && num == pendingManagedWardPlacementObserf.Key.Item2)
					{
						if (list2 == null)
						{
							list2 = new List<(ZDOID, long)>();
						}
						list2.Add(pendingManagedWardPlacementObserf.Key);
					}
				}
				else
				{
					ObserveAuthoritativeManagedWardPlacement(zDO);
					if (list == null)
					{
						list = new List<(ZDOID, long)>();
					}
					list.Add(pendingManagedWardPlacementObserf.Key);
				}
			}
			if (list2 != null)
			{
				for (int i = 0; i < list2.Count; i++)
				{
					(ZDOID, long) key = list2[i];
					if (PendingManagedWardPlacementObserves.TryGetValue(key, out var value2) && !value2.IsVerified)
					{
						PendingManagedWardPlacementObserves[key] = new PendingManagedWardPlacementObserve(value2.FirstSeenUtc, isVerified: true);
					}
				}
			}
			if (list != null)
			{
				for (int j = 0; j < list.Count; j++)
				{
					PendingManagedWardPlacementObserves.Remove(list[j]);
				}
			}
		}

		private static void HandleNotifyManagedWardMapStateChanged(long sender, ZPackage pkg)
		{
			//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_0055: 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_009d: 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)
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || pkg == null)
			{
				return;
			}
			ZDOID val;
			uint num;
			try
			{
				val = pkg.ReadZDOID();
				num = pkg.ReadUInt();
			}
			catch
			{
				return;
			}
			if (((ZDOID)(ref val)).IsNone() || !TryResolveAuthoritativePlayerIdFromSender(sender, out var _))
			{
				return;
			}
			ZDOMan instance = ZDOMan.instance;
			ZDO val2 = ((instance != null) ? instance.GetZDO(val) : null);
			if (val2 == null || !val2.IsValid() || !IsManagedWardZdo(val2) || val2.GetOwner() != sender)
			{
				return;
			}
			uint dataRevision = val2.DataRevision;
			if (num <= dataRevision || num - dataRevision <= 128)
			{
				PendingManagedWardMapStateRefresh value;
				if (num <= dataRevision)
				{
					PendingManagedWardMapStateRefreshes.Remove(val);
					ManagedWardMapStateService.NotifyWardMutation(val2);
				}
				else if (!PendingManagedWardMapStateRefreshes.TryGetValue(val, out value) || value.ExpectedDataRevision < num)
				{
					PendingManagedWardMapStateRefreshes[val] = new PendingManagedWardMapStateRefresh(num, DateTime.UtcNow);
				}
			}
		}

		private static void ProcessPendingManagedWardMapStateRefreshes()
		{
			//IL_0076: 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_00c0: 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_00f5: Unknown result type (might be due to invalid IL or missing references)
			if (PendingManagedWardMapStateRefreshes.Count == 0 || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			ZDOMan instance = ZDOMan.instance;
			if (instance == null)
			{
				return;
			}
			List<ZDOID> list = null;
			DateTime utcNow = DateTime.UtcNow;
			foreach (KeyValuePair<ZDOID, PendingManagedWardMapStateRefresh> pendingManagedWardMapStateRefresh in PendingManagedWardMapStateRefreshes)
			{
				PendingManagedWardMapStateRefresh value = pendingManagedWardMapStateRefresh.Value;
				bool flag = utcNow - value.FirstSeenUtc >= PendingManagedWardMapStateRefreshLifetime;
				ZDO zDO = instance.GetZDO(pendingManagedWardMapStateRefresh.Key);
				if (zDO == null || !zDO.IsValid())
				{
					if (flag)
					{
						if (list == null)
						{
							list = new List<ZDOID>();
						}
						list.Add(pendingManagedWardMapStateRefresh.Key);
					}
				}
				else if (!IsManagedWardZdo(zDO))
				{
					if (list == null)
					{
						list = new List<ZDOID>();
					}
					list.Add(pendingManagedWardMapStateRefresh.Key);
				}
				else if (zDO.DataRevision >= value.ExpectedDataRevision || flag)
				{
					ManagedWardMapStateService.NotifyWardMutation(zDO);
					if (list == null)
					{
						list = new List<ZDOID>();
					}
					list.Add(pendingManagedWardMapStateRefresh.Key);
				}
			}
			if (list != null)
			{
				for (int i = 0; i < list.Count; i++)
				{
					PendingManagedWardMapStateRefreshes.Remove(list[i]);
				}
			}
		}

		private static void ResetIdentityAuthState()
		{
			ServerPlayerAccountIdsByPlayerId.Clear();
			ServerSessionIdentitiesBySender.Clear();
		}

		internal static string GetWardSteamAccountId(PrivateArea? area)
		{
			return GetWardSteamAccountId(WardPrivateAreaSafeAccess.GetZdo(area));
		}

		internal static string GetWardSteamAccountId(ZDO? zdo)
		{
			return NormalizeAccountId(((zdo != null) ? zdo.GetString("stuw_owner_account_id", string.Empty) : null) ?? string.Empty);
		}

		internal static string ResolveWardSteamAccountId(ZDO? zdo, long playerId = 0L, string fallbackSteamAccountId = "")
		{
			string text = NormalizeAccountId(((zdo != null) ? zdo.GetString("stuw_owner_account_id", string.Empty) : null) ?? string.Empty);
			if (!string.IsNullOrWhiteSpace(text))
			{
				return text;
			}
			string text2 = NormalizeAccountId(fallbackSteamAccountId);
			if (!string.IsNullOrWhiteSpace(text2))
			{
				return text2;
			}
			if (playerId != 0L)
			{
				return GetPlayerAccountId(playerId);
			}
			return string.Empty;
		}

		internal static string GetPlayerAccountId(Player? player)
		{
			if (!((Object)(object)player == (Object)null))
			{
				return GetPlayerAccountId(player.GetPlayerID());
			}
			return string.Empty;
		}

		internal unsafe static string GetPlayerAccountId(long playerId)
		{
			//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)
			if (playerId == 0L)
			{
				return string.Empty;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null && localPlayer.GetPlayerID() == playerId)
			{
				string localPlayerAccountId = GetLocalPlayerAccountId();
				if (!string.IsNullOrWhiteSpace(localPlayerAccountId))
				{
					RememberServerPlayerAccountId(playerId, localPlayerAccountId);
					return localPlayerAccountId;
				}
			}
			string cachedServerPlayerAccountId = GetCachedServerPlayerAccountId(playerId);
			if (!string.IsNullOrWhiteSpace(cachedServerPlayerAccountId))
			{
				return cachedServerPlayerAccountId;
			}
			string serverSessionAccountId = GetServerSessionAccountId(playerId);
			if (!string.IsNullOrWhiteSpace(serverSessionAccountId))
			{
				return serverSessionAccountId;
			}
			PlayerInfo? val = FindPlayerInfo(playerId);
			if (!val.HasValue)
			{
				return string.Empty;
			}
			try
			{
				PlayerInfo value = val.Value;
				string text = NormalizeAccountId(((object)(*(PlatformUserID*)(&value.m_userInfo.m_id))/*cast due to .constrained prefix*/).ToString());
				RememberServerPlayerAccountId(playerId, text);
				return text;
			}
			catch
			{
				return string.Empty;
			}
		}

		internal static string GetPlayerSteamIdDisplay(long playerId)
		{
			return GetPlayerAccountId(playerId);
		}

		internal static string GetPlayerName(long playerId)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			if (playerId == 0L)
			{
				return string.Empty;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null && localPlayer.GetPlayerID() == playerId)
			{
				return localPlayer.GetPlayerName();
			}
			PlayerInfo? val = FindPlayerInfo(playerId);
			if (val.HasValue)
			{
				return val.Value.m_name ?? string.Empty;
			}
			return GetServerSessionPlayerName(playerId);
		}

		internal static string NormalizeAccountIdValue(string? rawAccountId)
		{
			return NormalizeAccountId(rawAccountId);
		}

		internal static long ResolvePlayerIdFromSender(long sender)
		{
			//IL_008d: 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_0059: 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)
			if (sender == 0L)
			{
				return 0L;
			}
			if (TryResolvePlayerIdFromSessionId(sender, out var playerId))
			{
				return playerId;
			}
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
			{
				if (TryGetServerSessionIdentity(sender, out var sessionIdentity))
				{
					if (sessionIdentity.PlayerId != 0L)
					{
						return sessionIdentity.PlayerId;
					}
					RefreshServerSessionIdentity(ZNet.instance.GetPeer(sender));
					if (TryGetServerSessionIdentity(sender, out sessionIdentity) && sessionIdentity.PlayerId != 0L)
					{
						return sessionIdentity.PlayerId;
					}
				}
				else
				{
					RefreshServerSessionIdentity(ZNet.instance.GetPeer(sender));
					if (TryGetServerSessionIdentity(sender, out sessionIdentity) && sessionIdentity.PlayerId != 0L)
					{
						return sessionIdentity.PlayerId;
					}
				}
			}
			ZNet instance = ZNet.instance;
			long playerId2 = GetPlayerId((instance != null) ? instance.GetPeer(sender) : null);
			if (playerId2 == 0L)
			{
				return GetLocalHostPlayerId(sender);
			}
			return playerId2;
		}

		internal static bool TryResolveAuthoritativePlayerIdFromSender(long sender, out long playerId)
		{
			playerId = ResolvePlayerIdFromSender(sender);
			if (playerId != 0L)
			{
				return true;
			}
			return false;
		}

		internal static bool IsAuthoritativeServerSender(long sender)
		{
			ZRoutedRpc instance = ZRoutedRpc.instance;
			if (sender != 0L && instance != null)
			{
				return sender == instance.GetServerPeerID();
			}
			return false;
		}

		internal static string GetAuthoritativeAccountIdFromSender(long sender, long playerId = 0L)
		{
			//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)
			if (sender != 0L)
			{
				if (TryGetServerSessionIdentity(sender, out var sessionIdentity) && !string.IsNullOrWhiteSpace(sessionIdentity.AccountId))
				{
					return sessionIdentity.AccountId;
				}
				if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
				{
					RefreshServerSessionIdentity(ZNet.instance.GetPeer(sender));
					if (TryGetServerSessionIdentity(sender, out sessionIdentity) && !string.IsNullOrWhiteSpace(sessionIdentity.AccountId))
					{
						return sessionIdentity.AccountId;
					}
				}
			}
			if (playerId != 0L)
			{
				return GetPlayerAccountId(playerId);
			}
			return string.Empty;
		}

		internal static bool TryResolveClaimedPlayerIdFromSender(long sender, long claimedPlayerId, out long playerId)
		{
			playerId = 0L;
			if (claimedPlayerId == 0L)
			{
				return false;
			}
			Player player = Player.GetPlayer(claimedPlayerId);
			if ((Object)(object)player != (Object)null && ((Character)player).GetOwner() == sender)
			{
				playerId = claimedPlayerId;
				return true;
			}
			long num = ResolvePlayerIdFromSender(sender);
			if (num == claimedPlayerId && num != 0L)
			{
				playerId = num;
				return true;
			}
			return false;
		}

		internal static long GetPlayerIdFromSender(long sender)
		{
			return ResolvePlayerIdFromSender(sender);
		}

		internal static void RefreshServerSessionIdentity(ZNetPeer? peer, ZDOID characterIdOverride = default(ZDOID))
		{
			//IL_0036: 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_0037: 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_0040: 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)
			if (peer != null && peer.m_uid != 0L && !((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer())
			{
				ZDOID val = ((!((ZDOID)(ref characterIdOverride)).IsNone()) ? characterIdOverride : peer.m_characterID);
				long playerId = GetPlayerId(val);
				string text = ResolveServerSessionAccountId(playerId, val);
				if (string.IsNullOrWhiteSpace(text))
				{
					text = ResolveServerPeerAccountId(peer);
				}
				string playerName = ResolveServerSessionPlayerName(peer, val, playerId);
				ServerSessionIdentity serverSessionIdentity = new ServerSessionIdentity(peer.m_uid, val, playerId, text, playerName);
				ServerSessionIdentitiesBySender[peer.m_uid] = serverSessionIdentity;
				WardRecentPlayers.RememberAuthenticatedIdentity(serverSessionIdentity);
			}
		}

		internal static void ForgetServerSessionIdentity(ZNetPeer? peer)
		{
			if (peer == null || peer.m_uid == 0L)
			{
				return;
			}
			ManagedWardReportService.ForgetSender(peer.m_uid);
			if (ServerSessionIdentitiesBySender.TryGetValue(peer.m_uid, out var value))
			{
				WardRecentPlayers.ForgetAuthenticatedIdentity(value);
				GuildsCompat.ForgetServerPlayerGuildIdentity(value.PlayerId, value.AccountId, value.PlayerName);
				if (value.PlayerId != 0L)
				{
					WardAdminDebugAccess.ForgetServerPlayer(value.PlayerId);
				}
			}
			ServerSessionIdentitiesBySender.Remove(peer.m_uid);
		}

		private static bool TryResolvePlayerIdFromSessionId(long sender, out long playerId)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			playerId = GetLocalHostPlayerId(sender);
			if (playerId != 0L)
			{
				return true;
			}
			PlayerInfo? val = FindPlayerInfoBySessionId(sender);
			if (val.HasValue)
			{
				playerId = GetPlayerId(val.Value.m_characterID);
				if (playerId != 0L)
				{
					return true;
				}
			}
			ZRoutedRpc instance = ZRoutedRpc.instance;
			object obj = ((instance != null) ? instance.GetPeer(sender) : null);
			if (obj == null)
			{
				ZNet instance2 = ZNet.instance;
				obj = ((instance2 != null) ? instance2.GetPeer(sender) : null);
			}
			ZNetPeer val2 = (ZNetPeer)obj;
			if (val2 != null)
			{
				playerId = GetPlayerId(val2.m_characterID);
				if (playerId != 0L)
				{
					return true;
				}
			}
			return false;
		}

		private static long GetLocalHostPlayerId(long sender)
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return 0L;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return 0L;
			}
			long playerID = localPlayer.GetPlayerID();
			if (playerID == 0L)
			{
				return 0L;
			}
			if (((Character)localPlayer).GetOwner() != sender)
			{
				return 0L;
			}
			return playerID;
		}

		private static long GetPlayerId(ZNetPeer? peer)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			if (peer != null)
			{
				return GetPlayerId(peer.m_characterID);
			}
			return 0L;
		}

		private static long GetPlayerId(ZDOID characterId)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if (((ZDOID)(ref characterId)).IsNone())
			{
				return 0L;
			}
			ZDOMan instance = ZDOMan.instance;
			ZDO obj = ((instance != null) ? instance.GetZDO(characterId) : null);
			if (obj == null)
			{
				return 0L;
			}
			return obj.GetLong(ZDOVars.s_playerID, 0L);
		}

		private static PlayerInfo? FindPlayerInfo(long playerId)
		{
			//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_0037: 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_0059: Unknown result type (might be due to invalid IL or missing references)
			List<PlayerInfo> list = ZNet.instance?.m_players;
			if (list == null)
			{
				return null;
			}
			for (int i = 0; i < list.Count; i++)
			{
				PlayerInfo val = list[i];
				ZDOMan instance = ZDOMan.instance;
				ZDO obj = ((instance != null) ? instance.GetZDO(val.m_characterID) : null);
				if (((obj != null) ? obj.GetLong(ZDOVars.s_playerID, 0L) : 0) == playerId)
				{
					return val;
				}
			}
			return null;
		}

		private static PlayerInfo? FindPlayerInfoByCharacterId(ZDOID characterId)
		{
			//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_0045: 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)
			if (((ZDOID)(ref characterId)).IsNone())
			{
				return null;
			}
			List<PlayerInfo> list = ZNet.instance?.m_players;
			if (list == null)
			{
				return null;
			}
			for (int i = 0; i < list.Count; i++)
			{
				PlayerInfo value = list[i];
				if (((ZDOID)(ref value.m_characterID)).Equals(characterId))
				{
					return value;
				}
			}
			return null;
		}

		private static PlayerInfo? FindPlayerInfoBySessionId(long sessionId)
		{
			//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_0047: Unknown result type (might be due to invalid IL or missing references)
			if (sessionId == 0L)
			{
				return null;
			}
			List<PlayerInfo> list = ZNet.instance?.m_players;
			if (list == null)
			{
				return null;
			}
			for (int i = 0; i < list.Count; i++)
			{
				PlayerInfo value = list[i];
				if (((ZDOID)(ref value.m_characterID)).UserID == sessionId)
				{
					return value;
				}
			}
			return null;
		}

		private static bool TryGetServerSessionIdentity(long sender, out ServerSessionIdentity sessionIdentity)
		{
			return ServerSessionIdentitiesBySender.TryGetValue(sender, out sessionIdentity);
		}

		private unsafe static string ResolveServerSessionAccountId(long playerId, ZDOID characterId)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			if (playerId != 0L)
			{
				string cachedServerPlayerAccountId = GetCachedServerPlayerAccountId(playerId);
				if (!string.IsNullOrWhiteSpace(cachedServerPlayerAccountId))
				{
					return cachedServerPlayerAccountId;
				}
			}
			PlayerInfo? val = FindPlayerInfoByCharacterId(characterId);
			if (!val.HasValue && playerId != 0L)
			{
				val = FindPlayerInfo(playerId);
			}
			if (!val.HasValue)
			{
				return string.Empty;
			}
			try
			{
				PlayerInfo value = val.Value;
				string text = NormalizeAccountId(((object)(*(PlatformUserID*)(&value.m_userInfo.m_id))/*cast due to .constrained prefix*/).ToString());
				if (playerId != 0L && !string.IsNullOrWhiteSpace(text))
				{
					RememberServerPlayerAccountId(playerId, text);
				}
				return text;
			}
			catch
			{
				return string.Empty;
			}
		}

		private static string ResolveServerPeerAccountId(ZNetPeer peer)
		{
			//IL_0000: 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_002e: 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)
			try
			{
				return NormalizeAccountId((((int)ZNet.m_onlineBackend == 0) ? new PlatformUserID(ZNet.instance.m_steamPlatform, peer.m_socket.GetHostName()) : new PlatformUserID(peer.m_socket.GetHostName())).m_userID.ToString());
			}
			catch
			{
				return string.Empty;
			}
		}

		private static string ResolveServerSessionPlayerName(ZNetPeer peer, ZDOID characterId, long playerId)
		{
			//IL_0014: 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)
			if (!string.IsNullOrWhiteSpace(peer.m_playerName))
			{
				return peer.m_playerName;
			}
			PlayerInfo? val = FindPlayerInfoByCharacterId(characterId);
			if (val.HasValue)
			{
				return val.Value.m_name ?? string.Empty;
			}
			if (playerId != 0L)
			{
				return GetPlayerName(playerId);
			}
			return string.Empty;
		}

		private static string GetServerSessionAccountId(long playerId)
		{
			if (playerId == 0L)
			{
				return string.Empty;
			}
			foreach (ServerSessionIdentity value in ServerSessionIdentitiesBySender.Values)
			{
				if (value.PlayerId == playerId && !string.IsNullOrWhiteSpace(value.AccountId))
				{
					return value.AccountId;
				}
			}
			return string.Empty;
		}

		private static string GetServerSessionPlayerName(long playerId)
		{
			if (playerId == 0L)
			{
				return string.Empty;
			}
			foreach (ServerSessionIdentity value in ServerSessionIdentitiesBySender.Values)
			{
				if (value.PlayerId == playerId && !string.IsNullOrWhiteSpace(value.PlayerName))
				{
					return value.PlayerName;
				}
			}
			return string.Empty;
		}

		private static bool TryGetServerSessionSenderUid(long playerId, out long senderUid)
		{
			senderUid = 0L;
			if (playerId == 0L)
			{
				return false;
			}
			foreach (ServerSessionIdentity value in ServerSessionIdentitiesBySender.Values)
			{
				if (value.PlayerId == playerId && value.SenderUid != 0L)
				{
					senderUid = value.SenderUid;
					return true;
				}
			}
			return false;
		}

		private static void RefreshServerSessionAccountIds(long playerId, string accountId)
		{
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			if (playerId == 0L || string.IsNullOrWhiteSpace(accountId))
			{
				return;
			}
			List<long> list = null;
			foreach (KeyValuePair<long, ServerSessionIdentity> item in ServerSessionIdentitiesBySender)
			{
				if (item.Value.PlayerId == playerId)
				{
					if (list == null)
					{
						list = new List<long>();
					}
					list.Add(item.Key);
				}
			}
			if (list != null)
			{
				string accountId2 = NormalizeAccountId(accountId);
				for (int i = 0; i < list.Count; i++)
				{
					long key = list[i];
					ServerSessionIdentity serverSessionIdentity = ServerSessionIdentitiesBySender[key];
					ServerSessionIdentitiesBySender[key] = new ServerSessionIdentity(serverSessionIdentity.SenderUid, serverSessionIdentity.CharacterZdoId, serverSessionIdentity.PlayerId, accountId2, serverSessionIdentity.PlayerName);
				}
			}
		}

		private static string GetCachedServerPlayerAccountId(long playerId)
		{
			if (playerId == 0L || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return string.Empty;
			}
			if (!ServerPlayerAccountIdsByPlayerId.TryGetValue(playerId, out string value))
			{
				return string.Empty;
			}
			return value;
		}

		private static void RememberServerPlayerAccountId(long playerId, string accountId)
		{
			if (playerId != 0L && !((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer())
			{
				string text = NormalizeAccountId(accountId);
				if (!string.IsNullOrWhiteSpace(text) && (!ServerPlayerAccountIdsByPlayerId.TryGetValue(playerId, out string value) || !SameAccountId(value, text)))
				{
					ServerPlayerAccountIdsByPlayerId[playerId] = text;
					RefreshServerSessionAccountIds(playerId, text);
				}
			}
		}

		private static string GetLocalPlayerAccountId()
		{
			try
			{
				return NormalizeAccountId(((object)Unsafe.As<PlatformUserID, PlatformUserID>(ref UserInfo.GetLocalUser().UserId)/*cast due to .constrained prefix*/).ToString());
			}
			catch
			{
				return string.Empty;
			}
		}

		private static string NormalizeAccountId(string? rawAccountId)
		{
			return GuildIdentityPolicy.NormalizeAccountId(rawAccountId);
		}

		private static bool SameAccountId(string left, string right)
		{
			return string.Equals(NormalizeAccountId(left), NormalizeAccountId(right), StringComparison.Ordinal);
		}

		internal static string GetReportFilePath()
		{
			return Path.Combine(Paths.ConfigPath, "STUWard.WardCountReport.yml");
		}

		private static string GetCurrentWorldName()
		{
			ZNet instance = ZNet.instance;
			string text = ((instance != null) ? instance.GetWorldName() : null);
			if (!string.IsNullOrWhiteSpace(text))
			{
				return text.Trim();
			}
			return "unknown_world";
		}

		private static long GetCurrentWorldUid()
		{
			ZNet instance = ZNet.instance;
			if (instance == null)
			{
				return 0L;
			}
			return instance.GetWorldUID();
		}

		internal static bool TryWriteWardCountReport(out string reportPath, out int trackedAccounts, out int totalWards, out int unresolvedOwners)
		{
			reportPath = GetReportFilePath();
			if (!TryBuildWardCountReport(out string reportContents, out trackedAccounts, out totalWards, out unresolvedOwners))
			{
				return false;
			}
			try
			{
				File.WriteAllText(reportPath, reportContents);
				return true;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Failed to write ward report file '" + reportPath + "': " + ex.Message));
				return false;
			}
		}

		internal static bool TryBuildWardCountReport(out string reportContents, out int trackedAccounts, out int totalWards, out int unresolvedOwners)
		{
			reportContents = string.Empty;
			trackedAccounts = 0;
			totalWards = 0;
			unresolvedOwners = 0;
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return false;
			}
			try
			{
				ZDOMan instance = ZDOMan.instance;
				if (instance == null)
				{
					return false;
				}
				IReadOnlyDictionary<string, int> wardLimitOverrides = ManagedWardConfigFileService.CurrentSnapshot.WardLimitOverrides;
				List<ManagedWardScanEntry> list = BuildManagedWardScanEntries(instance);
				List<KeyValuePair<string, int>> list2 = CollectReportWardCountsByAccount(list);
				list2.Sort(delegate(KeyValuePair<string, int> left, KeyValuePair<string, int> right)
				{
					int num2 = right.Value.CompareTo(left.Value);
					return (num2 == 0) ? string.CompareOrdinal(left.Key, right.Key) : num2;
				});
				List<ManagedWardReportAccountEntry> list3 = new List<ManagedWardReportAccountEntry>(list2.Count);
				for (int num = 0; num < list2.Count; num++)
				{
					KeyValuePair<string, int> keyValuePair = list2[num];
					list3.Add(new ManagedWardReportAccountEntry(keyValuePair.Key, keyValuePair.Value, GetEffectiveWardLimitForAccount(keyValuePair.Key), wardLimitOverrides.ContainsKey(keyValuePair.Key)));
				}
				List<KeyValuePair<long, int>> unresolvedWardOwnerCounts = CollectUnresolvedWardOwnerCounts(list);
				List<KeyValuePair<long, int>> playerAccountMapGapCounts = CollectPlayerAccountMapGapCounts(list);
				ManagedWardReportBuildResult managedWardReportBuildResult = ManagedWardReportBuilder.Build(new ManagedWardReportSnapshot("STUWard", DateTime.UtcNow, GetCurrentWorldName(), GetCurrentWorldUid(), list.Count, list3, unresolvedWardOwnerCounts, playerAccountMapGapCounts));
				reportContents = managedWardReportBuildResult.Contents;
				trackedAccounts = managedWardReportBuildResult.TrackedAccounts;
				totalWards = managedWardReportBuildResult.TotalWards;
				unresolvedOwners = managedWardReportBuildResult.UnresolvedOwners;
				return true;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Failed to build ward report: " + ex.Message));
				return false;
			}
		}

		private static List<ManagedWardScanEntry> BuildManagedWardScanEntries(ZDOMan zdoMan)
		{
			int num = PrepareManagedWardPrefabScan(zdoMan);
			List<ManagedWardScanEntry> list = new List<ManagedWardScanEntry>(num);
			for (int i = 0; i < num; i++)
			{
				ZDO val = ManagedWardPrefabScanBuffer[i];
				if (IsManagedWardZdo(val))
				{
					long num2 = val.GetLong(ZDOVars.s_creator, 0L);
					list.Add(new ManagedWardScanEntry(num2, NormalizeAccountIdValue(ResolveWardSteamAccountId(val, num2, string.Empty))));
				}
			}
			return list;
		}

		private static List<KeyValuePair<string, int>> CollectReportWardCountsByAccount(IReadOnlyList<ManagedWardScanEntry> scanEntries)
		{
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.Ordinal);
			for (int i = 0; i < scanEntries.Count; i++)
			{
				string accountId = scanEntries[i].AccountId;
				if (!string.IsNullOrWhiteSpace(accountId))
				{
					dictionary[accountId] = ((!dictionary.TryGetValue(accountId, out var value)) ? 1 : (value + 1));
				}
			}
			return new List<KeyValuePair<string, int>>(dictionary);
		}

		private static List<KeyValuePair<long, int>> CollectUnresolvedWardOwnerCounts(IReadOnlyList<ManagedWardScanEntry> scanEntries)
		{
			Dictionary<long, int> dictionary = new Dictionary<long, int>();
			for (int i = 0; i < scanEntries.Count; i++)
			{
				ManagedWardScanEntry managedWardScanEntry = scanEntries[i];
				if (string.IsNullOrWhiteSpace(managedWardScanEntry.AccountId))
				{
					long ownerPlayerId = managedWardScanEntry.OwnerPlayerId;
					dictionary[ownerPlayerId] = ((!dictionary.TryGetValue(ownerPlayerId, out var value)) ? 1 : (value + 1));
				}
			}
			return SortWardCountEntries(dictionary);
		}

		private static List<KeyValuePair<long, int>> CollectPlayerAccountMapGapCounts(IReadOnlyList<ManagedWardScanEntry> scanEntries)
		{
			Dictionary<long, int> dictionary = new Dictionary<long, int>();
			Dictionary<long, string> cachedPlayerAccountIds = new Dictionary<long, string>();
			for (int i = 0; i < scanEntries.Count; i++)
			{
				long ownerPlayerId = scanEntries[i].OwnerPlayerId;
				if (ownerPlayerId != 0L && string.IsNullOrWhiteSpace(GetCachedReportPlayerAccountId(ownerPlayerId, cachedPlayerAccountIds)))
				{
					dictionary[ownerPlayerId] = ((!dictionary.TryGetValue(ownerPlayerId, out var value)) ? 1 : (value + 1));
				}
			}
			return SortWardCountEntries(dictionary);
		}

		private static string GetCachedReportPlayerAccountId(long playerId, Dictionary<long, string> cachedPlayerAccountIds)
		{
			if (playerId == 0L)
			{
				return string.Empty;
			}
			if (cachedPlayerAccountIds.TryGetValue(playerId, out string value))
			{
				return value;
			}
			return cachedPlayerAccountIds[playerId] = GetPlayerAccountId(playerId);
		}

		private static List<KeyValuePair<long, int>> SortWardCountEntries(Dictionary<long, int> countsByCreatorId)
		{
			List<KeyValuePair<long, int>> list = new List<KeyValuePair<long, int>>(countsByCreatorId);
			list.Sort(delegate(KeyValuePair<long, int> left, KeyValuePair<long, int> right)
			{
				int num = right.Value.CompareTo(left.Value);
				return (num == 0) ? left.Key.CompareTo(right.Key) : num;
			});
			return list;
		}
	}
	[HarmonyPatch(typeof(ZDOMan), "Load")]
	internal static class ZdoManLoadWardOwnershipPatch
	{
		private static void Postfix(ZDOMan __instance)
		{
			WardOwnership.OnAuthoritativeWorldZdosLoaded(__instance);
		}
	}
	[HarmonyPatch(typeof(ZNet), "Awake")]
	internal static class ZNetAwakeWardOwnershipPatch
	{
		private static void Postfix()
		{
			ManagedWardLifecycle.NotifySessionReset();
		}
	}
	[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
	internal static class ZNetRpcPeerInfoWardOwnershipPatch
	{
		private static void Postfix(ZNet __instance, ZRpc rpc)
		{
			//IL_0012: 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)
			if (__instance.IsServer())
			{
				WardOwnership.RefreshServerSessionIdentity(__instance.GetPeer(rpc));
			}
		}
	}
	[HarmonyPatch(typeof(ZNet), "RPC_CharacterID")]
	internal static class ZNetRpcCharacterIdWardOwnershipPatch
	{
		private static void Postfix(ZNet __instance, ZRpc rpc, ZDOID characterID)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.IsServer())
			{
				WardOwnership.RefreshServerSessionIdentity(__instance.GetPeer(rpc), characterID);
			}
		}
	}
	[HarmonyPatch(typeof(ZNet), "Disconnect")]
	internal static class ZNetDisconnectWardOwnershipPatch
	{
		private static void Prefix(ZNet __instance, ZNetPeer peer)
		{
			if (__instance.IsServer())
			{
				WardOwnership.ForgetServerSessionIdentity(peer);
			}
		}
	}
	[HarmonyPatch(typeof(Player), "Start")]
	internal static class PlayerStartWardOwnershipPatch
	{
		private static void Postfix(Player __instance)
		{
			WardGuiController.Instance?.CloseWardUi();
			WardOwnership.RefreshServerPlayerAccountIdForPlayer(__instance);
			WardRecentPlayers.RememberLocalServerPlayer(__instance);
			WardAdminDebugAccess.UpdateLocalState(__instance, force: true);
			WardMinimapPinsManager.UpdateLocalState(__instance, force: true);
			GuildsCompat.OnLocalPlayerStarted(__instance);
		}
	}
	[HarmonyPatch(typeof(Player), "OnDeath")]
	internal static class PlayerOnDeathWardUiPatch
	{
		private static void Prefix(Player __instance)
		{
			if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
			{
				WardGuiController.Instance?.CloseWardUi();
			}
		}
	}
	[HarmonyPatch(typeof(Player), "OnRespawn")]
	internal static class PlayerOnRespawnWardUiPatch
	{
		private static void Postfix(Player __instance)
		{
			if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
			{
				WardGuiController.Instance?.CloseWardUi();
			}
		}
	}
	[HarmonyPatch(typeof(Terminal), "TryRunCommand")]
	internal static class TerminalTryRunCommandWardReportPatch
	{
		private static bool Prefix(Terminal __instance, string text)
		{
			return !ManagedWardReportService.TryHandleConsoleCommand(__instance, text);
		}
	}
	[HarmonyPatch(typeof(Terminal), "Awake")]
	internal static class TerminalAwakeWardReportCommandPatch
	{
		private static void Postfix(Terminal __instance)
		{
			ManagedWardReportService.EnsureConsoleCommandRegistered(__instance);
		}
	}
	internal readonly struct ManagedWardRegistryEntry
	{
		internal ZDOID ZdoId { get; }

		internal long OwnerPlayerId { get; }

		internal string CharacterKey { get; }

		internal int GuildId { get; }

		internal ManagedWardRegistryEntry(ZDOID zdoId, long ownerPlayerId, string characterKey, int guildId)
		{
			//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;
			OwnerPlayerId = ownerPlayerId;
			CharacterKey = characterKey ?? string.Empty;
			GuildId = guildId;
		}
	}
	internal static class ManagedWardRegistry
	{
		private static readonly Dictionary<ZDOID, ManagedWardRegistryEntry> ManagedWardRegistryEntriesByZdoId = new Dictionary<ZDOID, ManagedWardRegistryEntry>();

		private static readonly Dictionary<long, HashSet<ZDOID>> ManagedWardIdsByOwnerPlayerId = new Dictionary<long, HashSet<ZDOID>>();

		private static readonly Dictionary<int, HashSet<ZDOID>> ManagedWardIdsByGuildId = new Dictionary<int, HashSet<ZDOID>>();

		private static readonly Dictionary<string, HashSet<ZDOID>> ManagedWardIdsByCharacterKey = new Dictionary<string, HashSet<ZDOID>>(StringComparer.Ordinal);

		internal static void Reset()
		{
			ManagedWardRegistryEntriesByZdoId.Clear();
			ManagedWardIdsByOwnerPlayerId.Clear();
			ManagedWardIdsByGuildId.Clear();
			ManagedWardIdsByCharacterKey.Clear();
		}

		internal static void UpsertEntry(ZDO? zdo)
		{
			//IL_0047: 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_0062: Unknown result type (might be due to invalid IL or missing references)
			if (zdo == null || !zdo.IsValid() || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			if (!WardOwnership.IsManagedWardZdo(zdo))
			{
				RemoveEntry(zdo.m_uid);
				return;
			}
			ManagedWardRegistryEntry managedWardRegistryEntry = BuildManagedWardRegistryEntry(zdo);
			if (ManagedWardRegistryEntriesByZdoId.TryGetValue(managedWardRegistryEntry.ZdoId, out var value))
			{
				RemoveManagedWardRegistryIndexes(value);
			}
			ManagedWardRegistryEntriesByZdoId[managedWardRegistryEntry.ZdoId] = managedWardRegistryEntry;
			AddManagedWardRegistryIndexes(managedWardRegistryEntry);
		}

		internal static void RemoveEntry(ZDOID zdoId)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (!((ZDOID)(ref zdoId)).IsNone() && ManagedWardRegistryEntriesByZdoId.Remove(zdoId, out var value))
			{
				RemoveManagedWardRegistryIndexes(value);
			}
		}

		internal static int CollectCandidateIds(HashSet<ZDOID> candidateWardIds, HashSet<long>? targetPlayerIds, HashSet<string>? targetCharacterKeys, HashSet<int>? affectedGuildIds, bool fullRefresh)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			candidateWardIds.Clear();
			if (fullRefresh)
			{
				foreach (KeyValuePair<ZDOID, ManagedWardRegistryEntry> item in ManagedWardRegistryEntriesByZdoId)
				{
					candidateWardIds.Add(item.Key);
				}
				return candidateWardIds.Count;
			}
			if (targetPlayerIds != null)
			{
				foreach (long targetPlayerId in targetPlayerIds)
				{
					UnionManagedWardRegistryIds(candidateWardIds, ManagedWardIdsByOwnerPlayerId, targetPlayerId);
				}
			}
			if (targetCharacterKeys != null)
			{
				foreach (string targetCharacterKey in targetCharacterKeys)
				{
					if (!string.IsNullOrWhiteSpace(targetCharacterKey))
					{
						UnionManagedWardRegistryIds(candidateWardIds, ManagedWardIdsByCharacterKey, targetCharacterKey);
					}
				}
			}
			if (affectedGuildIds != null)
			{
				foreach (int affectedGuildId in affectedGuildIds)
				{
					if (affectedGuildId != 0)
					{
						UnionManagedWardRegistryIds(candidateWardIds, ManagedWardIdsByGuildId, affectedGuildId);
					}
				}
			}
			return candidateWardIds.Count;
		}

		private static ManagedWardRegistryEntry BuildManagedWardRegistryEntry(ZDO zdo)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			long num = zdo.GetLong(ZDOVars.s_creator, 0L);
			string accountId = WardOwnership.NormalizeAccountIdValue(WardOwnership.ResolveWardSteamAccountId(zdo, num));
			string playerName = (WardPrivateAreaSafeAccess.GetCreatorName(zdo) ?? string.Empty).Trim();
			string characterKey = GuildsCompat.BuildCharacterIdentityKey(accountId, playerName);
			int wardGuildId = GuildsCompat.GetWardGuildId(zdo);
			return new ManagedWardRegistryEntry(zdo.m_uid, num, characterKey, wardGuildId);
		}

		private static void AddManagedWardRegistryIndexes(ManagedWardRegistryEntry entry)
		{
			//IL_0017: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			if (entry.OwnerPlayerId != 0L)
			{
				AddManagedWardRegistryId(ManagedWardIdsByOwnerPlayerId, entry.OwnerPlayerId, entry.ZdoId);
			}
			if (entry.GuildId != 0)
			{
				AddManagedWardRegistryId(ManagedWardIdsByGuildId, entry.GuildId, entry.ZdoId);
			}
			if (!string.IsNullOrWhiteSpace(entry.CharacterKey))
			{
				AddManagedWardRegistryId(ManagedWardIdsByCharacterKey, entry.CharacterKey, entry.ZdoId);
			}
		}

		private static void RemoveManagedWardRegistryIndexes(ManagedWardRegistryEntry entry)
		{
			//IL_0017: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			if (entry.OwnerPlayerId != 0L)
			{
				RemoveManagedWardRegistryId(ManagedWardIdsByOwnerPlayerId, entry.OwnerPlayerId, entry.ZdoId);
			}
			if (entry.GuildId != 0)
			{
				RemoveManagedWardRegistryId(ManagedWardIdsByGuildId, entry.GuildId, entry.ZdoId);
			}
			if (!string.IsNullOrWhiteSpace(entry.CharacterKey))
			{
				RemoveManagedWardRegistryId(ManagedWardIdsByCharacterKey, entry.CharacterKey, entry.ZdoId);
			}
		}

		private static void AddManagedWardRegistryId<TKey>(Dictionary<TKey, HashSet<ZDOID>> indexedWardIds, TKey key, ZDOID zdoId) where TKey : notnull
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (!indexedWardIds.TryGetValue(key, out HashSet<ZDOID> value))
			{
				value = (indexedWardIds[key] = new HashSet<ZDOID>());
			}
			value.Add(zdoId);
		}

		private static void RemoveManagedWardRegistryId<TKey>(Dictionary<TKey, HashSet<ZDOID>> indexedWardIds, TKey key, ZDOID zdoId) where TKey : notnull
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (indexedWardIds.TryGetValue(key, out HashSet<ZDOID> value))
			{
				value.Remove(zdoId);
				if (value.Count == 0)
				{
					indexedWardIds.Remove(key);
				}
			}
		}

		private static void UnionManagedWardRegistryIds<TKey>(HashSet<ZDOID> candidateWardIds, Dictionary<TKey, HashSet<ZDOID>> indexedWardIds, TKey key) where TKey : notnull
		{
			//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_001e: Unknown result type (might be due to invalid IL or missing references)
			if (!indexedWardIds.TryGetValue(key, out HashSet<ZDOID> value))
			{
				return;
			}
			foreach (ZDOID item in value)
			{
				candidateWardIds.Add(item);
			}
		}
	}
	internal readonly struct PendingManagedWardPlacementObserve
	{
		internal DateTime FirstSeenUtc { get; }

		internal bool IsVerified { get; }

		internal PendingManagedWardPlacementObserve(DateTime firstSeenUtc, bool isVerified = false)
		{
			FirstSeenUtc = firstSeenUtc;
			IsVerified = isVerified;
		}
	}
	internal readonly struct PendingManagedWardMapStateRefresh
	{
		internal uint ExpectedDataRevision { get; }

		internal DateTime FirstSeenUtc { get; }

		internal PendingManagedWardMapStateRefresh(uint expectedDataRevision, DateTime firstSeenUtc)
		{
			ExpectedDataRevision = expectedDataRevision;
			FirstSeenUtc = firstSeenUtc;
		}
	}
	internal readonly struct ServerSessionIdentity
	{
		internal long SenderUid { get; }

		internal ZDOID CharacterZdoId { get; }

		internal long PlayerId { get; }

		internal string AccountId { get; }

		internal string PlayerName { get; }

		internal ServerSessionIdentity(long senderUid, ZDOID characterZdoId, long playerId, string accountId, string playerName)
		{
			//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)
			SenderUid = senderUid;
			CharacterZdoId = characterZdoId;
			PlayerId = playerId;
			AccountId = accountId ?? string.Empty;
			PlayerName = playerName ?? string.Empty;
		}
	}
	internal static class ManagedWardReportService
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static ConsoleEvent <>9__13_0;

			internal void <EnsureConsoleCommandRegistered>b__13_0(ConsoleEventArgs args)
			{
				TryHandleConsoleCommand(args.Context, args.FullLine);
			}
		}

		private const string RequestWardReportRpc = "STUWard_RequestWardReport";

		private const string ReceiveWardReportRpc = "STUWard_ReceiveWardReport";

		private const string WardReportConsoleCommand = "stuw_wardreport";

		private const int MaxReportBytes = 2097152;

		private const int MaxResponseMessageLength = 1024;

		private static readonly TimeSpan MinimumRequestInterval = TimeSpan.FromSeconds(5.0);

		private static readonly Dictionary<long, DateTime> LastRequestUtcBySender = new Dictionary<long, DateTime>();

		private static bool _rpcsRegistered;

		private static bool _consoleCommandRegistered;

		internal static void ResetRuntimeState()
		{
			_rpcsRegistered = false;
			LastRequestUtcBySender.Clear();
		}

		internal static void ForgetSender(long senderUid)
		{
			if (senderUid != 0L)
			{
				LastRequestUtcBySender.Remove(senderUid);
			}
		}

		internal static void RegisterRpcs()
		{
			ZRoutedRpc instance = ZRoutedRpc.instance;
			if (!_rpcsRegistered && instance != null)
			{
				instance.Register("STUWard_RequestWardReport", (Action<long>)HandleRequestWardReport);
				instance.Register<ZPackage>("STUWard_ReceiveWardReport", (Action<long, ZPackage>)HandleReceiveWardReport);
				_rpcsRegistered = true;
			}
		}

		internal static bool TryHandleConsoleCommand(Terminal? terminal, string? text)
		{
			if (string.IsNullOrWhiteSpace(text))
			{
				return false;
			}
			if (!(text?.Trim() ?? string.Empty).Equals("stuw_wardreport", StringComparison.OrdinalIgnoreCase))
			{
				return false;
			}
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				if (terminal != null)
				{
					terminal.AddString("STUWard: ward report is not available right now.");
				}
				return true;
			}
			if (ZNet.instance.IsServer())
			{
				WriteWardReportToTerminal(terminal);
				return true;
			}
			RegisterRpcs();
			if (terminal != null)
			{
				terminal.AddString("STUWard: requested ward report generation on the server.");
			}
			ZRoutedRpc instance = ZRoutedRpc.instance;
			if (instance != null)
			{
				instance.InvokeRoutedRPC("STUWard_RequestWardReport", Array.Empty<object>());
			}
			return true;
		}

		internal static void EnsureConsoleCommandRegistered(Terminal? terminal)
		{
			//IL_0040: 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_0037: Expected O, but got Unknown
			if (_consoleCommandRegistered)
			{
				AddCommandToAutocomplete(terminal);
				return;
			}
			object obj = <>c.<>9__13_0;
			if (obj == null)
			{
				ConsoleEvent val = delegate(ConsoleEventArgs args)
				{
					TryHandleConsoleCommand(args.Context, args.FullLine);
				};
				<>c.<>9__13_0 = val;
				obj = (object)val;
			}
			new ConsoleCommand("stuw_wardreport", "Generate the STUWard ward ownership/count report.", (ConsoleEvent)obj, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			_consoleCommandRegistered = true;
			AddCommandToAutocomplete(terminal);
		}

		private static void AddCommandToAutocomplete(Terminal? terminal)
		{
			if (!((Object)(object)terminal == (Object)null) && terminal.m_commandList != null && !terminal.m_commandList.Contains("stuw_wardreport"))
			{
				terminal.m_commandList.Add("stuw_wardreport");
				terminal.m_commandList.Sort(StringComparer.OrdinalIgnoreCase);
			}
		}

		private static void WriteWardReportToTerminal(Terminal? terminal)
		{
			if (WardOwnership.TryWriteWardCountReport(out string reportPath, out int trackedAccounts, out int totalWards, out int unresolvedOwners))
			{
				if (terminal != null)
				{
					terminal.AddString("STUWard: wrote ward report to " + reportPath);
				}
				if (terminal != null)
				{
					terminal.AddString(string.Format("{0}: tracked accounts={1}, total wards={2}, unresolved owner wards={3}", "STUWard", trackedAccounts, totalWards, unresolvedOwners));
				}
			}
			else if (terminal != null)
			{
				terminal.AddString("STUWard: failed to write ward report. Check the log for details.");
			}
		}

		private static void HandleRequestWardReport(long sender)
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || !WardOwnership.TryResolveAuthoritativePlayerIdFromSender(sender, out var playerId))
			{
				return;
			}
			DateTime utcNow = DateTime.UtcNow;
			if (LastRequestUtcBySender.TryGetValue(sender, out var value) && utcNow >= value && utcNow - value < MinimumRequestInterval)
			{
				return;
			}
			LastRequestUtcBySender[sender] = utcNow;
			string playerAccountId = WardOwnership.GetPlayerAccountId(playerId);
			string reportContents;
			int trackedAccounts;
			int totalWards;
			int unresolvedOwners;
			if (!WardAdminDebugAccess.IsAdminAccountId(playerAccountId))
			{
				Plugin.Log.LogWarning((object)$"Rejected ward report request from non-admin playerId={playerId} accountId='{playerAccountId}'.");
				SendWardReportResponse(sender, success: false, string.Empty, 0, 0, 0, "Ward report is only available to server admins.");
			}
			else if (WardOwnership.TryBuildWardCountReport(out reportContents, out trackedAccounts, out totalWards, out unresolvedOwners))
			{
				if (reportContents == null)
				{
					reportContents = string.Empty;
				}
				if (Encoding.UTF8.GetByteCount(reportContents) > 2097152)
				{
					Plugin.Log.LogWarning((object)$"Ward report for admin playerId={playerId} exceeds the {2097152}-byte response limit.");
					SendWardReportResponse(sender, success: false, string.Empty, 0, 0, 0, "The ward report is too large to transfer. Generate it from the server console instead.");
					return;
				}
				Plugin.Log.LogInfo((object)$"Prepared ward report for admin playerId={playerId}. tracked accounts={trackedAccounts}, total wards={totalWards}, unresolved owner wards={unresolvedOwners}");
				SendWardReportResponse(sender, success: true, reportContents, trackedAccounts, totalWards, unresolvedOwners, string.Empty);
			}
			else
			{
				Plugin.Log.LogWarning((object)$"Failed to build ward report for admin playerId={playerId}.");
				SendWardReportResponse(sender, success: false, string.Empty, 0, 0, 0, "Failed to generate ward report on the server. Check the server log for details.");
			}
		}

		private static void HandleReceiveWardReport(long sender, ZPackage pkg)
		{
			if (!WardOwnership.IsAuthoritativeServerSender(sender) || pkg == null)
			{
				return;
			}
			bool flag;
			int num;
			int num2;
			int num3;
			string text;
			string text2;
			try
			{
				flag = pkg.ReadBool();
				num = pkg.ReadInt();
				num2 = pkg.ReadInt();
				num3 = pkg.ReadInt();
				text = pkg.ReadString();
				text2 = pkg.ReadString();
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("STUWard: failed to read ward report response: " + ex.Message));
				return;
			}
			if (text.Length > 1024 || Encoding.UTF8.GetByteCount(text2) > 2097152)
			{
				Plugin.Log.LogWarning((object)"STUWard: rejected an oversized ward report response.");
				return;
			}
			if (!flag)
			{
				Plugin.Log.LogWarning((object)("STUWard: " + text));
				return;
			}
			string reportFilePath = WardOwnership.GetReportFilePath();
			try
			{
				File.WriteAllText(reportFilePath, text2);
				Plugin.Log.LogInfo((object)("STUWard: wrote ward report to " + reportFilePath));
				Plugin.Log.LogInfo((object)string.Format("{0}: tracked accounts={1}, total wards={2}, unresolved owner wards={3}", "STUWard", num, num2, num3));
			}
			catch (Exception ex2)
			{
				Plugin.Log.LogWarning((object)("STUWard: failed to write ward report to " + reportFilePath + ": " + ex2.Message));
			}
		}

		private static void SendWardReportResponse(long receiverUid, bool success, string reportContents, int trackedAccounts, int totalWards, int unresolvedOwners, string message)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected O, but got Unknown
			ZRoutedRpc instance = ZRoutedRpc.instance;
			if (instance != null)
			{
				if (reportContents == null)
				{
					reportContents = string.Empty;
				}
				if (message == null)
				{
					message = string.Empty;
				}
				if (Encoding.UTF8.GetByteCount(reportContents) > 2097152 || message.Length > 1024)
				{
					success = false;
					reportContents = string.Empty;
					trackedAccounts = 0;
					totalWards = 0;
					unresolvedOwners = 0;
					message = "The ward report response exceeded its transfer limit.";
				}
				ZPackage val = new ZPackage();
				val.Write(success);
				val.Write(trackedAccounts);
				val.Write(totalWards);
				val.Write(unresolvedOwners);
				val.Write(message);
				val.Write(reportContents);
				instance.InvokeRoutedRPC(receiverUid, "STUWard_ReceiveWardReport", new object[1] { val });
			}
		}
	}
	internal readonly struct ManagedWardReportAccountEntry
	{
		internal string AccountId { get; }

		internal int WardCount { get; }

		internal int EffectiveLimit { get; }

		internal bool HasOverride { get; }

		internal ManagedWardReportAccountEntry(string accountId, int wardCount, int effectiveLimit, bool hasOverride)
		{
			AccountId = accountId ?? string.Empty;
			WardCount = wardCount;
			EffectiveLimit = effectiveLimit;
			HasOverride = hasOverride;
		}
	}
	internal readonly struct ManagedWardReportSnapshot
	{
		internal string ModName { get; }

		internal DateTime GeneratedAtUtc { get; }

		internal string WorldName { get; }

		internal long WorldUid { get; }

		internal int TotalTrackedWards { get; }

		internal List<ManagedWardReportAccountEntry> Accounts { get; }

		internal List<KeyValuePair<long, int>> UnresolvedWardOwnerCounts { get; }

		internal List<KeyValuePair<long, int>> PlayerAccountMapGapCounts { get; }

		internal ManagedWardReportSnapshot(string modName, DateTime generatedAtUtc, string worldName, long worldUid, int totalTrackedWards, List<ManagedWardReportAccountEntry> accounts, List<KeyValuePair<long, int>> unresolvedWardOwnerCounts, List<KeyValuePair<long, int>> playerAccountMapGapCounts)
		{
			ModName = modName ?? string.Empty;
			GeneratedAtUtc = generatedAtUtc;
			WorldName = worldName ?? string.Empty;
			WorldUid = worldUid;
			TotalTrackedWards = totalTrackedWards;
			Accounts = accounts ?? new List<ManagedWardReportAccountEntry>();
			UnresolvedWardOwnerCounts = unresolvedWardOwnerCounts ?? new List<KeyValuePair<long, int>>();
			PlayerAccountMapGapCounts = playerAccountMapGapCounts ?? new List<KeyValuePair<long, int>>();
		}
	}
	internal readonly struct ManagedWardReportBuildResult
	{
		internal string Contents { get; }

		internal int TrackedAccounts { get; }

		internal int TotalWards { get; }

		internal int UnresolvedOwners { get; }

		internal ManagedWardReportBuildResult(string contents, int trackedAccounts, int totalWards, int unresolvedOwners)
		{
			Contents = contents ?? string.Empty;
			TrackedAccounts = trackedAccounts;
			TotalWards = totalWards;
			UnresolvedOwners = unresolvedOwners;
		}
	}
	internal static class ManagedWardReportBuilder
	{
		internal static ManagedWardReportBuildResult Build(ManagedWardReportSnapshot snapshot)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("# Generated by " + snapshot.ModName);
			stringBuilder.AppendLine($"# Generated at UTC: {snapshot.GeneratedAtUtc:O}");
			stringBuilder.AppendLine("# World: " + snapshot.WorldName);
			stringBuilder.AppendLine($"# World UID: {snapshot.WorldUid}");
			stringBuilder.AppendLine("accounts:");
			if (snapshot.Accounts.Count == 0)
			{
				stringBuilder.AppendLine("  {}");
			}
			else
			{
				for (int i = 0; i < snapshot.Accounts.Count; i++)
				{
					ManagedWardReportAccountEntry managedWardReportAccountEntry = snapshot.Accounts[i];
					stringBuilder.AppendLine("  " + FormatYamlScalar(managedWardReportAccountEntry.AccountId) + ":");
					stringBuilder.AppendLine($"    wards: {managedWardReportAccountEntry.WardCount}");
					stringBuilder.AppendLine($"    limit: {managedWardReportAccountEntry.EffectiveLimit}");
					stringBuilder.AppendLine("    override: " + managedWardReportAccountEntry.HasOverride.ToString().ToLowerInvariant());
				}
			}
			AppendWardCountSection(stringBuilder, "unresolved_wards_by_creator_id", snapshot.UnresolvedWardOwnerCounts);
			AppendWardCountSection(stringBuilder, "player_account_map_gaps", snapshot.PlayerAccountMapGapCounts);
			return new ManagedWardReportBuildResult(stringBuilder.ToString(), snapshot.Accounts.Count, snapshot.TotalTrackedWards, CountWardEntries(snapshot.UnresolvedWardOwnerCounts));
		}

		private static void AppendWardCountSection(StringBuilder builder, string sectionName, List<KeyValuePair<long, int>> entries)
		{
			builder.AppendLine(sectionName + ":");
			if (entries.Count == 0)
			{
				builder.AppendLine("  {}");
				return;
			}
			for (int i = 0; i < entries.Count; i++)
			{
				KeyValuePair<long, int> keyValuePair = entries[i];
				builder.AppendLine($"  {keyValuePair.Key}: {keyValuePair.Value}");
			}
		}

		private static int CountWardEntries(List<KeyValuePair<long, int>> entries)
		{
			int num = 0;
			for (int i = 0; i < entries.Count; i++)
			{
				num += Math.Max(0, entries[i].Value);
			}
			return num;
		}

		private static string FormatYamlScalar(string value)
		{
			string text = (value ?? string.Empty).Replace("'", "''");
			return "'" + text + "'";
		}
	}
	internal static class ManagedWardMapStateService
	{
		internal static void NotifyWardMutation(PrivateArea? area, bool liveDisplayRefresh = false)
		{
			if (WardMinimapVisibilityIndex.NotifyWardStateChanged(area))
			{
				WardMinimapPinsManager.NotifyWardDataMayHaveChanged(liveDisplayRefresh);
			}
		}

		internal static void NotifyWardMutation(ZDO? zdo, bool notifyPins = true, bool liveDisplayRefresh = false)
		{
			if (WardMinimapVisibilityIndex.NotifyWardStateChanged(zdo) && notifyPins)
			{
				WardMinimapPinsManager.NotifyWardDataMayHaveChanged(liveDisplayRefresh);
			}
		}

		internal static void NotifyWardRemoved(ZDOID zdoId, bool liveDisplayRefresh = false)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			if (!((ZDOID)(ref zdoId)).IsNone() && WardMinimapVisibilityIndex.ForgetWard(zdoId))
			{
				WardMinimapPinsManager.NotifyWardDataMayHaveChanged(liveDisplayRefresh);
			}
		}

		internal static void NotifyViewerProjectionChanged(bool fullRefresh, HashSet<long>? recipientPeerUids = null, bool refreshImmediatelyIfVisible = false)
		{
			WardMinimapPinsManager.NotifyLocalWardDataMayHaveChanged(refreshImmediatelyIfVisible);
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer() && (fullRefresh || recipientPeerUids == null || recipientPeerUids.Count > 0))
			{
				WardMinimapPinsManager.QueueServerViewerRefreshRecipients(fullRefresh ? null : recipientPeerUids);
			}
		}

		internal static void InvalidateProjection(bool liveDisplayRefresh = false)
		{
			WardMinimapVisibilityIndex.InvalidateAll();
			WardMinimapPinsManager.NotifyWardDataMayHaveChanged(liveDisplayRefresh);
		}

		internal static void RequestLocalDisplayRefresh(bool refreshImmediatelyIfVisible = false)
		{
			WardMinimapPinsManager.NotifyLocalWardDataMayHaveChanged(refreshImmediatelyIfVisible);
		}

		internal static void RequestDisplayRefresh(bool liveDisplayRefresh = false)
		{
			WardMinimapPinsManager.NotifyWardDataMayHaveChanged(liveDisplayRefresh);
		}
	}
	internal static class ManagedWardRuntimeLifecycle
	{
		private static ZRoutedRpc? _boundRoutedRpc;

		internal static void ResetSession()
		{
			_boundRoutedRpc = null;
			DoorRpcUseDoorPatch.Reset();
			ManagedWardInteractionRpc.ResetLocalInteractionState();
			WardSettings.ResetLocalBoundaryFlashState();
			ManagedWardRuntimeContexts.Reset();
			WardAccess.ResetManagedWardCache();
			WardPermittedSnapshots.ClearCache();
			WardPrivateAreaSafeAccess.ResetRuntimeState();
			WardRecentPlayers.ResetRuntimeState();
			WardAdminDebugAccess.ResetRuntimeState();
			ManagedWardReportService.ResetRuntimeState();
			WardOwnership.ResetRuntimeState();
			GuildsCompat.ResetRuntimeState();
			WardMinimapPinsManager.ResetRuntimeState();
			WardMinimapVisibilityIndex.ResetRuntimeState();
		}

		internal static void BindNetwork()
		{
			ZRoutedRpc instance = ZRoutedRpc.instance;
			if (instance != null && _boundRoutedRpc != instance)
			{
				WardAdminDebugAccess.EnsureRuntimeBindings();
				WardOwnership.RegisterRpcs();
				ManagedWardInteractionRpc.RegisterRoutedRpcs(instance);
				WardSettings.RegisterRoutedRpcs(instance);
				WardRecentPlayers.RegisterRpcs();
				ManagedWardReportService.RegisterRpcs();
				GuildsCompat.EnsureRuntimeBindings();
				WardMinimapPinsManager.EnsureRuntimeBindings();
				_boundRoutedRpc = instance;
			}
		}

		internal static void Update()
		{
			BindNetwork();
			ManagedWardConfigFileService.Update();
			WardRecentPlayers.Update();
			if (WardPermittedSnapshots.HasPendingRuntimeWork())
			{
				WardPermittedSnapshots.Update();
			}
			if (WardOwnership.HasPendingRuntimeWork())
			{
				WardOwnership.Update();
			}
			WardSettings.UpdateLocalBoundaryFlash();
			GuildsCompat.Update();
			ManagedWardPresenceService.Update();
			if (WardMinimapPinsManager.HasPendingRuntimeWork())
			{
				WardMinimapPinsManager.Update();
			}
		}
	}
	internal readonly struct ManagedWardProjection
	{
		internal string AccountId { get; }

		internal bool HasResolvedGuild { get; }

		internal WardGuildIdentity Guild { get; }

		internal ManagedWardProjection(string accountId, bool hasResolvedGuild, WardGuildIdentity guild)
		{
			AccountId = accountId ?? string.Empty;
			HasResolvedGuild = hasResolvedGuild;
			Guild = guild;
		}
	}
	internal readonly struct ManagedWardProjectionApplyResult
	{
		internal bool AccountChanged { get; }

		internal bool GuildChanged { get; }

		internal bool AnyChanged
		{
			get
			{
				if (!AccountChanged)
				{
					return GuildChanged;
				}
				return true;
			}
		}

		internal ManagedWardProjectionApplyResult(bool accountChanged, bool guildChanged)
		{
			AccountChanged = accountChanged;
			GuildChanged = guildChanged;
		}
	}
	internal static class ManagedWardProjectionService
	{
		internal static ManagedWardProjection ResolveProjection(ZDO? zdo, long ownerPlayerId, string wardSteamAccountId)
		{
			if (zdo == null)
			{
				return default(ManagedWardProjection);
			}
			string text = ((ownerPlayerId != 0L) ? WardOwnership.GetPlayerAccountId(ownerPlayerId) : string.Empty);
			string text2 = ((!string.IsNullOrWhiteSpace(text)) ? WardOwnership.NormalizeAccountIdValue(text) : WardOwnership.ResolveWardSteamAccountId(zdo, ownerPlayerId, wardSteamAccountId));
			if (string.IsNullOrWhiteSpace(text2))
			{
				return new ManagedWardProjection(string.Empty, hasResolvedGuild: false, default(WardGuildIdentity));
			}
			string wardOwnerNameForProjection = GuildsCompat.GetWardOwnerNameForProjection(zdo);
			if (GuildsCompat.TryResolveProjectedGuildIdentity(ownerPlayerId, text2, wardOwnerNameForProjection, out var guild))
			{
				return new ManagedWardProjection(text2, hasResolvedGuild: true, guild);
			}
			return new ManagedWardProjection(text2, hasResolvedGuild: false, default(WardGuildIdentity));
		}

		internal static ManagedWardProjection ResolveExplicitProjection(long ownerPlayerId, string wardSteamAccountId, WardGuildIdentity guild)
		{
			string text = ((ownerPlayerId != 0L) ? WardOwnership.GetPlayerAccountId(ownerPlayerId) : string.Empty);
			return new ManagedWardProjection((!string.IsNullOrWhiteSpace(text)) ? WardOwnership.NormalizeAccountIdValue(text) : WardOwnership.NormalizeAccountIdValue(wardSteamAccountId), hasResolvedGuild: true, guild);
		}

		internal static ManagedWardProjectionApplyResult RefreshProjection(ZDO? zdo, long ownerPlayerId, string wardSteamAccountId)
		{
			return ApplyProjection(zdo, ResolveProjection(zdo, ownerPlayerId, wardSteamAccountId));
		}

		internal static ManagedWardProjectionApplyResult ApplyProjection(ZDO? zdo, ManagedWardProjection projection, bool requireServer = true)
		{
			if (zdo == null || (requireServer && ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())))
			{
				return default(ManagedWardProjectionApplyResult);
			}
			bool accountChanged = false;
			if (!string.IsNullOrWhiteSpace(projection.AccountId) && !string.Equals(WardOwnership.GetWardSteamAccountId(zdo), projection.AccountId, StringComparison.Ordinal))
			{
				zdo.Set("stuw_owner_account_id", projection.AccountId);
				accountChanged = true;
			}
			bool guildChanged = false;
			if (projection.HasResolvedGuild)
			{
				guildChanged = ApplyProjectedGuildMetadata(zdo, projection.Guild);
			}
			return new ManagedWardProjectionApplyResult(accountChanged, guildChanged);
		}

		internal static ManagedWardProjectionApplyResult ObserveAuthoritativeWard(ZDO? zdo, long ownerPlayerId, string wardSteamAccountId, bool authoritativeMetadataChanged, bool liveDisplayRefresh = false)
		{
			return FinalizeMutation(zdo, RefreshProjection(zdo, ownerPlayerId, wardSteamAccountId), authoritativeMetadataChanged, forceSendWhenMetadataChanged: true, notifyObserved: true, notifyPins: false, liveDisplayRefresh);
		}

		internal static ManagedWardProjectionApplyResult RefreshProjectedMetadata(ZDO? zdo, long ownerPlayerId, string wardSteamAccountId, bool forceSendWhenMetadataChanged = false, bool liveDisplayRefresh = false)
		{
			return FinalizeMutation(zdo, RefreshProjection(zdo, ownerPlayerId, wardSteamAccountId), authoritativeMetadataChanged: false, forceSendWhenMetadataChanged, notifyObserved: false, notifyPins: false, liveDisplayRefresh);
		}

		internal static ManagedWardProjectionApplyResult ApplyOwnedLocalProjection(ZDO? zdo, ManagedWardProjection projection, bool forceSendWhenMetadataChanged = true, bool liveDisplayRefresh = false)
		{
			return FinalizeMutation(zdo, ApplyProjection(zdo, projection, requireServer: false), authoritativeMetadataChanged: false, forceSendWhenMetadataChanged, notifyObserved: false, notifyPins: true, liveDisplayRefresh);
		}

		private static ManagedWardProjectionApplyResult FinalizeMutation(ZDO? zdo, ManagedWardProjectionApplyResult projectionResult, bool authoritativeMetadataChanged, bool forceSendWhenMetadataChanged, bool notifyObserved, bool notifyPins, bool liveDisplayRefresh)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			ManagedWardRegistry.UpsertEntry(zdo);
			if (zdo != null && zdo.IsValid() && forceSendWhenMetadataChanged && (authoritativeMetadataChanged || projectionResult.AnyChanged))
			{
				ZDOMan instance = ZDOMan.instance;
				if (instance != null)
				{
					instance.ForceSendZDO(zdo.m_uid);
				}
			}
			if (notifyObserved)
			{
				ManagedWardMapStateService.NotifyWardMutation(zdo, notifyPins: true, liveDisplayRefresh);
			}
			else if (projectionResult.AnyChanged)
			{
				ManagedWardMapStateService.NotifyWardMutation(zdo, notifyPins, liveDisplayRefresh);
			}
			return projectionResult;
		}

		private static bool ApplyProjectedGuildMetadata(ZDO zdo, WardGuildIdentity guild)
		{
			bool result = false;
			if (zdo.GetInt("stuw_guild_id", 0) != guild.Id)
			{
				zdo.Set("stuw_guild_id", guild.Id);
				result = true;
			}
			string text = guild.Name ?? string.Empty;
			if (!string.Equals(zdo.GetString("stuw_guild_name", string.Empty), text, StringComparison.Ordinal))
			{
				zdo.Set("stuw_guild_name", text);
				result = true;
			}
			return result;
		}
	}
	internal readonly struct WardGuildIdentity
	{
		internal int Id { get; }

		internal string Name { get; }

		internal WardGuildIdentity(int id, string name)
		{
			Id = id;
			Name = name ?? string.Empty;
		}
	}
	internal readonly struct ManagedWardAccessActor
	{
		internal long PlayerId { get; }

		internal WardGuildIdentity PlayerGuild { get; }

		internal bool IsAdminDebug { get; }

		internal ManagedWardAccessActor(long playerId, WardGuildIdentity playerGuild, bool isAdminDebug)
		{
			PlayerId = playerId;
			PlayerGuild = playerGuild;
			IsAdminDebug = isAdminDebug;
		}
	}
	internal readonly struct ManagedWardAccessSubject
	{
		internal long OwnerPlayerId { get; }

		internal WardGuildIdentity WardGuild { get; }

		internal bool Permitted { get; }

		internal ManagedWardAccessSubject(long ownerPlayerId, WardGuildIdentity wardGuild, bool permitted)
		{
			OwnerPlayerId = ownerPlayerId;
			WardGuild = wardGuild;
			Permitted = permitted;
		}
	}
	internal static class ManagedWardAccessPolicy
	{
		internal static bool CanAccess(ManagedWardAccessActor actor, ManagedWardAccessSubject subject)
		{
			if (subject.OwnerPlayerId != 0L && subject.OwnerPlayerId == actor.PlayerId)
			{
				return true;
			}
			if (actor.IsAdminDebug)
			{
				return true;
			}
			if (!subject.Permitted)
			{
				return HasMatchingGuild(actor.PlayerGuild, subject.WardGuild);
			}
			return true;
		}

		internal static bool HasMatchingGuild(WardGuildIdentity playerGuild, WardGuildIdentity wardGuild)
		{
			if (playerGuild.Id != 0 && wardGuild.Id != 0)
			{
				return playerGuild.Id == wardGuild.Id;
			}
			return false;
		}
	}
	internal readonly struct GuildAccountLookupCandidates
	{
		internal string PrimaryAccountId { get; }

		internal string FallbackAccountId { get; }

		internal bool HasFallback
		{
			get
			{
				if (!string.IsNullOrWhiteSpace(FallbackAccountId))
				{
					return !string.Equals(PrimaryAccountId, FallbackAccountId, StringComparison.Ordinal);
				}
				return false;
			}
		}

		internal GuildAccountLookupCandidates(string primaryAccountId, string fallbackAccountId)
		{
			PrimaryAccountId = primaryAccountId ?? string.Empty;
			FallbackAccountId = fallbackAccountId ?? string.Empty;
		}
	}
	internal static class GuildIdentityPolicy
	{
		private const string SteamPrefix = "Steam_";

		internal static string NormalizeAccountId(string? accountId)
		{
			string text = accountId?.Trim() ?? string.Empty;
			if (!text.StartsWith("Steam_", StringComparison.Ordinal))
			{
				return text;
			}
			return text.Substring("Steam_".Length);
		}

		internal static GuildAccountLookupCandidates GetAccountLookupCandidates(string accountId)
		{
			string text = accountId?.Trim() ?? string.Empty;
			if (string.IsNullOrWhiteSpace(text))
			{
				return new GuildAccountLookupCandidates(string.Empty, string.Empty);
			}
			if (text.StartsWith("Steam_", StringComparison.Ordinal))
			{
				string fallbackAccountId = text.Substring("Steam_".Length);
				return new GuildAccountLookupCandidates(text, fallbackAccountId);
			}
			if (!IsNumericAccountId(text))
			{
				return new GuildAccountLookupCandidates(text, string.Empty);
			}
			return new GuildAccountLookupCandidates("Steam_" + text, text);
		}

		internal static bool CanApplyAuthoritativeGuild(int reportedGuildId, int authoritativeGuildId)
		{
			if (authoritativeGuildId == 0)
			{
				return reportedGuildId == 0;
			}
			return true;
		}

		private static bool IsNumericAccountId(string accountId)
		{
			for (int i = 0; i < accountId.Length; i++)
			{
				if (!char.IsDigit(accountId[i]))
				{
					return false;
				}
			}
			return accountId.Length > 0;
		}
	}
	internal enum BuildingDamageBlockReason
	{
		None,
		NoAccess,
		FriendlyWardProtection,
		UnresolvedSender
	}
	internal enum DamageSourceKind
	{
		Unknown,
		Player,
		TamedCreature,
		MonsterAI
	}
	internal readonly struct BuildingDamagePolicyInput
	{
		internal bool IsBuildingTarget { get; }

		internal DamageSourceKind SourceKind { get; }

		internal long PlayerId { get; }

		internal bool InsideEnabledWard { get; }

		internal bool BlocksHostileCreatureDamage { get; }

		internal bool PlayerHasAccess { get; }

		internal BuildingDamagePolicyInput(bool isBuildingTarget, DamageSourceKind sourceKind, long playerId, bool insideEnabledWard, bool blocksHostileCreatureDamage, bool playerHasAccess)
		{
			IsBuildingTarget = isBuildingTarget;
			SourceKind = sourceKind;
			PlayerId = playerId;
			InsideEnabledWard = insideEnabledWard;
			BlocksHostileCreatureDamage = blocksHostileCreatureDamage;
			PlayerHasAccess = playerHasAccess;
		}
	}
	internal static class BuildingDamagePolicy
	{
		internal static BuildingDamageBlockReason Evaluate(BuildingDamagePolicyInput input)
		{
			if (input.IsBuildingTarget && input.SourceKind == DamageSourceKind.MonsterAI && input.BlocksHostileCreatureDamage)
			{
				return BuildingDamageBlockReason.FriendlyWardProtection;
			}
			if (input.IsBuildingTarget && IsFriendlyBuildingDamageSource(input.SourceKind) && input.InsideEnabledWard)
			{
				return BuildingDamageBlockReason.FriendlyWardProtection;
			}
			if (input.PlayerId != 0L && !input.PlayerHasAccess)
			{
				return BuildingDamageBlockReason.NoAccess;
			}
			return BuildingDamageBlockReason.None;
		}

		private static bool IsFriendlyBuildingDamageSource(DamageSourceKind sourceKind)
		{
			if (sourceKind != DamageSourceKind.Player)
			{
				return sourceKind == DamageSourceKind.TamedCreature;
			}
			return true;
		}
	}
	internal static class WardLimitPolicy
	{
		internal static int GetEffectiveLimit(string accountId, IReadOnlyDictionary<string, int> overrides, int defaultLimit)
		{
			if (!string.IsNullOrWhiteSpace(accountId) && overrides != null && overrides.TryGetValue(accountId, out var value))
			{
				return value;
			}
			return defaultLimit;
		}

		internal static bool CanPlaceWard(int limit, int currentCount)
		{
			if (limit >= 0)
			{
				return currentCount < limit;
			}
			return true;
		}
	}
	internal readonly struct WardOverlapArea
	{
		internal int Id { get; }

		internal float X { get; }

		internal float Z { get; }

		internal float Radius { get; }

		internal long OwnerPlayerId { get; }

		internal int GuildId { get; }

		internal WardOverlapArea(int id, float x, float z, float radius, long ownerPlayerId, int guildId)
		{
			Id = id;
			X = x;
			Z = z;
			Radius = radius;
			OwnerPlayerId = ownerPlayerId;
			GuildId = guildId;
		}
	}
	internal readonly struct WardOverlapQuery
	{
		internal float X { get; }

		internal float Z { get; }

		internal float Radius { get; }

		internal long OwnerPlayerId { get; }

		internal int GuildId { get; }

		internal int IgnoredAreaId { get; }

		internal WardOverlapQuery(float x, float z, float radius, long ownerPlayerId, int guildId, int ignoredAreaId = 0)
		{
			X = x;
			Z = z;
			Radius = radius;
			OwnerPlayerId = ownerPlayerId;
			GuildId = guildId;
			IgnoredAreaId = ignoredAreaId;
		}
	}
	internal static class WardOverlapPolicy
	{
		internal static bool IsForeignOverlap(WardOverlapQuery query, WardOverlapArea area)
		{
			if (!ShouldIgnoreArea(query, area) && !SharesTrustedWardGroup(area, query))
			{
				return Overlaps(query, area);
			}
			return false;
		}

		internal static float GetMaxNonOverlappingRadius(float fallbackRadius, WardOverlapQuery query, IEnumerable<WardOverlapArea> areas)
		{
			float num = fallbackRadius;
			foreach (WardOverlapArea area in areas)
			{
				if (!ShouldIgnoreArea(query, area) && !SharesTrustedWardGroup(area, query))
				{
					float num2 = DistanceXZ(query.X, query.Z, area.X, area.Z) - area.Radius;
					if (num2 < num)
					{
						num = num2;
					}
				}
			}
			return Clamp(num, 0f, fallbackRadius);
		}

		internal static bool TryGetPlacementRadius(float minimumRadius, float maximumRadius, WardOverlapQuery query, IEnumerable<WardOverlapArea> areas, out float radius)
		{
			radius = GetMaxNonOverlappingRadius(maximumRadius, query, areas);
			return radius >= minimumRadius;
		}

		internal static bool Overlaps(WardOverlapQuery query, WardOverlapArea area)
		{
			return DistanceXZ(query.X, query.Z, area.X, area.Z) < area.Radius + query.Radius;
		}

		internal static bool SharesTrustedWardGroup(WardOverlapArea area, WardOverlapQuery query)
		{
			if (SharesDirectOwnerGroup(area.OwnerPlayerId, query.OwnerPlayerId))
			{
				return true;
			}
			if (area.GuildId != 0 && query.GuildId != 0)
			{
				return area.GuildId == query.GuildId;
			}
			return false;
		}

		private static bool ShouldIgnoreArea(WardOverlapQuery query, WardOverlapArea area)
		{
			if (query.IgnoredAreaId != 0)
			{
				return area.Id == query.IgnoredAreaId;
			}
			return false;
		}

		private static bool SharesDirectOwnerGroup(long leftCreatorPlayerId, long rightCreatorPlayerId)
		{
			if (leftCreatorPlayerId != 0L && rightCreatorPlayerId != 0L)
			{
				return leftCreatorPlayerId == rightCreatorPlayerId;
			}
			return false;
		}

		private static float DistanceXZ(float leftX, float leftZ, float rightX, float rightZ)
		{
			float num = leftX - rightX;
			float num2 = leftZ - rightZ;
			return (float)Math.Sqrt(num * num + num2 * num2);
		}

		private static float Clamp(float value, float min, float max)
		{
			if (value < min)
			{
				return min;
			}
			if (!(value > max))
			{
				return value;
			}
			return max;
		}
	}
	internal static class ManagedWardAccessEvaluator
	{
		internal static bool HasPlayerAccess(PrivateArea area, ManagedWardAccessActor actor)
		{
			return ManagedWardAccessPolicy.CanAccess(actor, BuildManagedWardAccessSubjectFromArea(area, actor));
		}

		internal static bool HasPlayerAccess(ZDO zdo, ManagedWardAccessActor actor)
		{
			return ManagedWardAccessPolicy.CanAccess(actor, BuildManagedWardAccessSubjectFromZdo(zdo, actor));
		}

		internal static bool TryCreateActorForAccessCheck(long playerId, out ManagedWardAccessActor actor)
		{
			if (playerId != 0L)
			{
				actor = CreateActor(playerId);
				return true;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				actor = default(ManagedWardAccessActor);
				return false;
			}
			actor = CreateActor(localPlayer.GetPlayerID(), GuildsCompat.GetPlayerGuildIdentity(localPlayer));
			return true;
		}

		internal static ManagedWardAccessActor CreateActor(long playerId)
		{
			return CreateActor(playerId, GuildsCompat.GetPlayerGuildIdentity(playerId));
		}

		internal static ManagedWardAccessActor CreateActor(long playerId, WardGuildIdentity playerGuild)
		{
			return new ManagedWardAccessActor(playerId, playerGuild, WardAdminDebugAccess.IsPlayerAdminDebugController(playerId));
		}

		internal static bool HasPlayerAccessToManagedWardIndexEntry(WardMinimapVisibilityIndexedEntry entry, long playerId, WardGuildIdentity playerGuild)
		{
			if (playerId == 0L)
			{
				return false;
			}
			ManagedWardAccessActor actor = CreateActor(playerId, playerGuild);
			return ManagedWardAccessPolicy.CanAccess(actor, BuildManagedWardAccessSubjectFromIndexEntry(entry, actor));
		}

		private static ManagedWardAccessSubject BuildManagedWardAccessSubjectFromArea(PrivateArea area, ManagedWardAccessActor actor)
		{
			ZDO zdo = WardPrivateAreaSafeAccess.GetZdo(area);
			if (zdo != null && zdo.IsValid())
			{
				return BuildManagedWardAccessSubjectFromZdo(zdo, actor);
			}
			return BuildManagedWardAccessSubjectCore(WardAccess.GetCanonicalCreatorPlayerId(area), GuildsCompat.GetWardGuildId(area), WardPrivateAreaSafeAccess.IsPlayerPermitted(area, actor.PlayerId));
		}

		private static ManagedWardAccessSubject BuildManagedWardAccessSubjectFromZdo(ZDO zdo, ManagedWardAccessActor actor)
		{
			return BuildManagedWardAccessSubjectCore(zdo.GetLong(ZDOVars.s_creator, 0L), GuildsCompat.ResolveWardGuildIdentityReadOnly(zdo).Id, WardPrivateAreaSafeAccess.IsPlayerPermitted(zdo, actor.PlayerId));
		}

		private static ManagedWardAccessSubject BuildManagedWardAccessSubjectFromIndexEntry(WardMinimapVisibilityIndexedEntry entry, ManagedWardAccessActor actor)
		{
			return new ManagedWardAccessSubject(entry.OwnerPlayerId, new WardGuildIdentity(entry.WardGuildId, string.Empty), IsPlayerPermitted(entry, actor.PlayerId));
		}

		private static ManagedWardAccessSubject BuildManagedWardAccessSubjectCore(long ownerPlayerId, int wardGuildId, bool permitted)
		{
			return new ManagedWardAccessSubject(ownerPlayerId, new WardGuildIdentity(wardGuildId, string.Empty), permitted);
		}

		private static bool IsPlayerPermitted(WardMinimapVisibilityIndexedEntry entry, long playerId)
		{
			for (int i = 0; i < entry.PermittedPlayerIds.Count; i++)
			{
				if (entry.PermittedPlayerIds[i] == playerId)
				{
					return true;
				}
			}
			return false;
		}
	}
	internal static class ManagedWardPresenceService
	{
		private const float TrustedPresenceSweepActiveDurationSeconds = 15f;

		private const float TrustedPlayerRangeBuffer = 8f;

		private const float TrustedPresenceGraceSeconds = 10f;

		private const float PresenceRefreshIntervalSeconds = 1f;

		private static readonly List<PrivateArea> TrustedPresenceCandidateBuffer = new List<PrivateArea>();

		private static readonly List<PrivateArea> TrustedPresenceCoverageBuffer = new List<PrivateArea>();

		private static bool _trustedPresenceSweepWasActive;

		private static float _trustedPresenceSweepActiveUntilTime = float.NegativeInfinity;

		private static float _nextTrustedPresenceSweepTime = float.NegativeInfinity;

		internal static void Invalidate()
		{
			ManagedWardRuntimeContexts.ResetPresenceStates();
			_trustedPresenceSweepActiveUntilTime = float.NegativeInfinity;
			_nextTrustedPresenceSweepTime = float.NegativeInfinity;
			_trustedPresenceSweepWasActive = false;
		}

		internal static void ResetRuntimeState()
		{
			ManagedWardRuntimeContexts.ResetPresenceStates();
			TrustedPresenceCandidateBuffer.Clear();
			TrustedPresenceCoverageBuffer.Clear();
			_trustedPresenceSweepWasActive = false;
			_trustedPresenceSweepActiveUntilTime = float.NegativeInfinity;
			_nextTrustedPresenceSweepTime = float.NegativeInfinity;
		}

		internal static void Update()
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			if (GetHostileCreatureStructureProtectionMode() != Plugin.HostileCreatureStructureProtectionMode.UnattendedOnly || !WardAccess.HasEnabledManagedWards())
			{
				if (_trustedPresenceSweepWasActive)
				{
					ManagedWardRuntimeContexts.ResetPresenceStates();
					_trustedPresenceSweepWasActive = false;
					_trustedPresenceSweepActiveUntilTime = float.NegativeInfinity;
					_nextTrustedPresenceSweepTime = float.NegativeInfinity;
				}
				return;
			}
			float time = Time.time;
			if (!_trustedPresenceSweepWasActive || time > _trustedPresenceSweepActiveUntilTime)
			{
				_trustedPresenceSweepWasActive = false;
				_trustedPresenceSweepActiveUntilTime = float.NegativeInfinity;
				_nextTrustedPresenceSweepTime = float.NegativeInfinity;
			}
			else if (!(time < _nextTrustedPresenceSweepTime))
			{
				SweepTrustedPlayerPresence(time);
				_nextTrustedPresenceSweepTime = time + 1f;
			}
		}

		internal static bool ShouldBlockHostileCreatureDamageToBuilding(Vector3 point)
		{
			//IL_0013: 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)
			return GetHostileCreatureStructureProtectionMode() switch
			{
				Plugin.HostileCreatureStructureProtectionMode.Off => false, 
				Plugin.HostileCreatureStructureProtectionMode.Always => IsInsideEnabledWard(point), 
				_ => ShouldBlockUnattendedHostileCreatureDamageToBuilding(point), 
			};
		}

		private static bool ShouldBlockUnattendedHostileCreatureDamageToBuilding(Vector3 point)
		{
			//IL_0006: 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)
			float time = Time.time;
			WardAccess.FillCandidateManagedWards(point, 0f, requireEnabled: true, TrustedPresenceCandidateBuffer);
			if (TrustedPresenceCandidateBuffer.Count == 0)
			{
				return false;
			}
			TrustedPresenceCoverageBuffer.Clear();
			for (int i = 0; i < TrustedPresenceCandidateBuffer.Count; i++)
			{
				PrivateArea val = TrustedPresenceCandidateBuffer[i];
				if (!((Object)(object)val == (Object)null) && val.IsInside(point, 0f))
				{
					TrustedPresenceCoverageBuffer.Add(val);
				}
			}
			if (TrustedPresenceCoverageBuffer.Count == 0)
			{
				return false;
			}
			EnsureTrustedPlayerPresenceSweepActivity(time, TrustedPresenceCoverageBuffer, 10f);
			for (int j = 0; j < TrustedPresenceCoverageBuffer.Count; j++)
			{
				if (!IsWardConsideredAttended(TrustedPresenceCoverageBuffer[j], time, 10f))
				{
					return true;
				}
			}
			return false;
		}

		private static bool IsInsideEnabledWard(Vector3 point)
		{
			//IL_0000: 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)
			WardAccess.FillCandidateManagedWards(point, 0f, requireEnabled: true, TrustedPresenceCandidateBuffer);
			if (TrustedPresenceCandidateBuffer.Count == 0)
			{
				return false;
			}
			for (int i = 0; i < TrustedPresenceCandidateBuffer.Count; i++)
			{
				PrivateArea val = TrustedPresenceCandidateBuffer[i];
				if ((Object)(object)val != (Object)null && val.IsInside(point, 0f))
				{
					return true;
				}
			}
			return false;
		}

		private static Plugin.HostileCreatureStructureProtectionMode GetHostileCreatureStructureProtectionMode()
		{
			if (Plugin.HostileCreatureStructureProtection == null)
			{
				return Plugin.HostileCreatureStructureProtectionMode.UnattendedOnly;
			}
			return Plugin.HostileCreatureStructureProtection.Value;
		}

		private static void EnsureTrustedPlayerPresenceSweepActivity(float now, IReadOnlyList<PrivateArea> coveringAreas, float graceSeconds)
		{
			if (!_trustedPresenceSweepWasActive || !(now <= _trustedPresenceSweepActiveUntilTime) || HasUnattendedPresenceState(coveringAreas, now, graceSeconds))
			{
				RefreshTrustedPlayerPresenceForAreas(now, coveringAreas);
				_nextTrustedPresenceSweepTime = now + 1f;
			}
			_trustedPresenceSweepWasActive = true;
			_trustedPresenceSweepActiveUntilTime = now + 15f;
		}

		private static void SweepTrustedPlayerPresence(float now)
		{
			//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_0055: 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)
			List<Player> allPlayers = Player.GetAllPlayers();
			if (allPlayers == null || allPlayers.Count == 0)
			{
				return;
			}
			float radius = 8f;
			for (int i = 0; i < allPlayers.Count; i++)
			{
				Player val = allPlayers[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				long playerID = val.GetPlayerID();
				if (playerID == 0L)
				{
					continue;
				}
				Vector3 position = ((Component)val).transform.position;
				ManagedWardAccessActor actor = ManagedWardAccessEvaluator.CreateActor(playerID);
				WardAccess.FillCandidateManagedWards(position, radius, requireEnabled: true, TrustedPresenceCandidateBuffer);
				for (int j = 0; j < TrustedPresenceCandidateBuffer.Count; j++)
				{
					PrivateArea val2 = TrustedPresenceCandidateBuffer[j];
					if (!((Object)(object)val2 == (Object)null) && val2.IsInside(position, 8f) && ManagedWardAccessEvaluator.HasPlayerAccess(val2, actor))
					{
						ManagedWardRuntimeContexts.GetOrCreate(val2).PresenceLastTrustedNearbyTime = now;
					}
				}
			}
		}

		private static void RefreshTrustedPlayerPresenceForAreas(float now, IReadOnlyList<PrivateArea> areas)
		{
			//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_006d: Unknown result type (might be due to invalid IL or missing references)
			if (areas.Count == 0)
			{
				return;
			}
			List<Player> allPlayers = Player.GetAllPlayers();
			if (allPlayers == null || allPlayers.Count == 0)
			{
				return;
			}
			for (int i = 0; i < allPlayers.Count; i++)
			{
				Player val = allPlayers[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				long playerID = val.GetPlayerID();
				if (playerID == 0L)
				{
					continue;
				}
				Vector3 position = ((Component)val).transform.position;
				ManagedWardAccessActor actor = ManagedWardAccessEvaluator.CreateActor(playerID);
				for (int j = 0; j < areas.Count; j++)
				{
					PrivateArea val2 = areas[j];
					if (!((Object)(object)val2 == (Object)null) && val2.IsInside(position, 8f) && ManagedWardAccessEvaluator.HasPlayerAccess(val2, actor))
					{
						ManagedWardRuntimeContexts.GetOrCreate(val2).PresenceLastTrustedNearbyTime = now;
					}
				}
			}
		}

		private static bool IsWardConsideredAttended(PrivateArea area, float now, float graceSeconds)
		{
			if (ManagedWardRuntimeContexts.TryGet(area, out ManagedWardRuntimeContext context))
			{
				return now - context.PresenceLastTrustedNearbyTime <= graceSeconds;
			}
			return false;
		}

		private static bool HasUnattendedPresenceState(IReadOnlyList<PrivateArea> coveringAreas, float now, float graceSeconds)
		{
			for (int i = 0; i < coveringAreas.Count; i++)
			{
				PrivateArea val = coveringAreas[i];
				if (!((Object)(object)val == (Object)null) && !IsWardConsideredAttended(val, now, graceSeconds))
				{
					return true;
				}
			}
			return false;
		}
	}
	internal readonly struct ManagedWardConfigSnapshot
	{
		internal IReadOnlyDictionary<string, int> WardLimitOverrides { get; }

		internal string ItemPrefabPolicyYaml { get; }

		internal ManagedWardConfigSnapshot(IReadOnlyDictionary<string, int> wardLimitOverrides, string itemPrefabPolicyYaml)
		{
			WardLimitOverrides = wardLimitOverrides;
			ItemPrefabPolicyYaml = itemPrefabPolicyYaml ?? string.Empty;
		}
	}
	internal static class ManagedWardConfigFileService
	{
		private sealed class ManagedWardConfigYaml
		{
			[YamlMember(Alias = "ward_limit_overrides")]
			public Dictionary<string, int>? WardLimitOverrides { get; set; }

			[YamlMember(Alias = "item_prefab_policy")]
			public ManagedWardItemPrefabPolicyYaml? ItemPrefabPolicy { get; set; }
		}

		internal sealed class ManagedWardItemPrefabPolicyYaml
		{
			[YamlMember(Alias = "blocked_item_prefabs")]
			public List<string>? BlockedItemPrefabs { get; set; }

			[YamlMember(Alias = "pickup_whitelist")]
			public List<string>? PickupWhitelist { get; set; }

			[YamlMember(Alias = "pickup_blacklist")]
			public List<string>? PickupBlacklist { get; set; }
		}

		internal const string ConfigFileName = "STUWard.yml";

		internal const int MaxItemPolicyYamlBytes = 262144;

		private const double ReloadIntervalSeconds = 1.0;

		private const long MaxConfigFileBytes = 2097152L;

		private const int MaxWardLimitOverrideCount = 4096;

		private const int MaxItemPrefabCountPerList = 4096;

		private const int MaxPrefabNameLength = 256;

		private static readonly IDeserializer Deserializer = new DeserializerBuilder().WithDuplicateKeyChecking().Build();

		private static readonly ISerializer Serializer = new SerializerBuilder().Build();

		private static readonly ManagedWardConfigSnapshot DefaultSnapshot = CreateDefaultSnapshot();

		private static ManagedWardConfigSnapshot _currentSnapshot = DefaultSnapshot;

		private static DateTime _lastProcessedWriteUtc = DateTime.MinValue;

		private static DateTime _nextReloadCheckUtc = DateTime.MinValue;

		private static bool _initialized;

		internal static ManagedWardConfigSnapshot CurrentSnapshot => _currentSnapshot;

		internal static event Action? ConfigChanged;

		internal static void Initialize()
		{
			if (!_initialized)
			{
				_initialized = true;
				Plugin.ConfigSync.SourceOfTruthChanged += HandleSourceOfTruthChanged;
				ReloadAuthoritativeLocalFile(force: true);
			}
		}

		internal static void Shutdown()
		{
			if (_initialized)
			{
				Plugin.ConfigSync.SourceOfTruthChanged -= HandleSourceOfTruthChanged;
				_initialized = false;
				_lastProcessedWriteUtc = DateTime.MinValue;
				_nextReloadCheckUtc = DateTime.MinValue;
				_currentSnapshot = DefaultSnapshot;
			}
		}

		internal static void Update()
		{
			if (_initialized && Plugin.ConfigSync.IsSourceOfTruth && !(DateTime.UtcNow < _nextReloadCheckUtc))
			{
				_nextReloadCheckUtc = DateTime.UtcNow.AddSeconds(1.0);
				ReloadLocalFile(force: false);
			}
		}

		private static void HandleSourceOfTruthChanged(bool isSourceOfTruth)
		{
			if (isSourceOfTruth)
			{
				ReloadAuthoritativeLocalFile(force: true);
			}
		}

		private static void ReloadAuthoritativeLocalFile(bool force)
		{
			if (Plugin.ConfigSync.IsSourceOfTruth)
			{
				EnsureConfigFileExists();
				_nextReloadCheckUtc = DateTime.MinValue;
				ReloadLocalFile(force);
			}
		}

		private static void ReloadLocalFile(bool force)
		{
			string configFilePath = GetConfigFilePath();
			if (!File.Exists(configFilePath))
			{
				EnsureConfigFileExists();
				if (!File.Exists(configFilePath))
				{
					return;
				}
			}
			DateTime lastWriteTimeUtc;
			string yaml;
			try
			{
				long length = new FileInfo(configFilePath).Length;
				if (length > 2097152)
				{
					Plugin.Log.LogWarning((object)$"Managed ward config file '{configFilePath}' is {length} bytes; the maximum is {2097152L} bytes. Keeping the last valid configuration.");
					_lastProcessedWriteUtc = File.GetLastWriteTimeUtc(configFilePath);
					return;
				}
				lastWriteTimeUtc = File.GetLastWriteTimeUtc(configFilePath);
				if (!force && lastWriteTimeUtc == _lastProcessedWriteUtc)
				{
					return;
				}
				yaml = File.ReadAllText(configFilePath);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Failed to read managed ward config file '" + configFilePath + "': " + ex.Message));
				return;
			}
			if (!TryParseYaml(yaml, out var snapshot))
			{
				_lastProcessedWriteUtc = lastWriteTimeUtc;
				return;
			}
			_lastProcessedWriteUtc = lastWriteTimeUtc;
			_currentSnapshot = snapshot;
			ManagedWardConfigFileService.ConfigChanged?.Invoke();
		}

		private static string GetConfigFilePath()
		{
			return Path.Combine(Paths.ConfigPath, "STUWard.yml");
		}

		private static void EnsureConfigFileExists()
		{
			string configFilePath = GetConfigFilePath();
			if (File.Exists(configFilePath))
			{
				return;
			}
			try
			{
				File.WriteAllText(configFilePath, GetDefaultConfigFileContents());
				Plugin.Log.LogInfo((object)("Created managed ward config file '" + configFilePath + "'."));
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Failed to create managed ward config file '" + configFilePath + "': " + ex.Message));
			}
		}

		private static bool TryParseYaml(string yaml, out ManagedWardConfigSnapshot snapshot)
		{
			snapshot = DefaultSnapshot;
			if (yaml == null)
			{
				yaml = string.Empty;
			}
			try
			{
				if ((long)Encoding.UTF8.GetByteCount(yaml) > 2097152L)
				{
					throw new FormatException($"The YAML exceeds the {2097152L}-byte limit.");
				}
				ManagedWardConfigYaml managedWardConfigYaml = (string.IsNullOrWhiteSpace(yaml) ? new ManagedWardConfigYaml() : (Deserializer.Deserialize<ManagedWardConfigYaml>(yaml) ?? new ManagedWardConfigYaml()));
				Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.Ordinal);
				if (managedWardConfigYaml.WardLimitOverrides != null)
				{
					if (managedWardConfigYaml.WardLimitOverrides.Count > 4096)
					{
						throw new FormatException($"ward_limit_overrides contains {managedWardConfigYaml.WardLimitOverrides.Count} entries; the maximum is {4096}.");
					}
					foreach (KeyValuePair<string, int> wardLimitOverride in managedWardConfigYaml.WardLimitOverrides)
					{
						string text = WardOwnership.NormalizeAccountIdValue(wardLimitOverride.Key);
						if (string.IsNullOrWhiteSpace(text) || !ulong.TryParse(text, out var _))
						{
							throw new FormatException("ward_limit_overrides contains invalid account id '" + wardLimitOverride.Key + "'.");
						}
						if (wardLimitOverride.Value < -1)
						{
							throw new FormatException($"ward_limit_overrides['{wardLimitOverride.Key}'] is {wardLimitOverride.Value}; only -1 or a non-negative ward count is allowed.");
						}
						if (dictionary.ContainsKey(text))
						{
							throw new FormatException("ward_limit_overrides contains multiple keys for normalized account id '" + text + "'.");
						}
						dictionary.Add(text, wardLimitOverride.Value);
					}
				}
				ManagedWardItemPrefabPolicyYaml? data = managedWardConfigYaml.ItemPrefabPolicy ?? new ManagedWardItemPrefabPolicyYaml();
				ValidateItemPrefabPolicy(data);
				string text2 = SerializeItemPrefabPolicy(data);
				if (Encoding.UTF8.GetByteCount(text2) > 262144)
				{
					throw new FormatException($"item_prefab_policy exceeds the {262144}-byte synchronized payload limit.");
				}
				snapshot = new ManagedWardConfigSnapshot(dictionary, text2);
				return true;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Failed to parse managed ward config YAML 'STUWard.yml': " + ex.Message));
				return false;
			}
		}

		private static string SerializeItemPrefabPolicy(ManagedWardItemPrefabPolicyYaml data)
		{
			return Serializer.Serialize(data);
		}

		internal static void ValidateItemPrefabPolicy(ManagedWardItemPrefabPolicyYaml data)
		{
			ValidatePrefabList(data.BlockedItemPrefabs, "blocked_item_prefabs");
			ValidatePrefabList(data.PickupWhitelist, "pickup_whitelist");
			ValidatePrefabList(data.PickupBlacklist, "pickup_blacklist");
		}

		private static void ValidatePrefabList(IReadOnlyCollection<string>? prefabNames, string fieldName)
		{
			if (prefabNames == null)
			{
				return;
			}
			if (prefabNames.Count > 4096)
			{
				throw new FormatException($"item_prefab_policy.{fieldName} contains {prefabNames.Count} entries; the maximum is {4096}.");
			}
			foreach (string prefabName in prefabNames)
			{
				if (string.IsNullOrWhiteSpace(prefabName))
				{
					throw new FormatException("item_prefab_policy." + fieldName + " contains an empty prefab name.");
				}
				if (prefabName.Length > 256)
				{
					throw new FormatException($"item_prefab_policy.{fieldName} contains a prefab name longer than {256} characters.");
				}
			}
		}

		private static string GetDefaultConfigFileContents()
		{
			ManagedWardConfigYaml graph = new ManagedWardConfigYaml
			{
				ItemPrefabPolicy = CreateDefaultItemPrefabPolicy()
			};
			ISerializer serializer = new SerializerBuilder().ConfigureDefaultValuesHandling(DefaultValuesHandling.OmitNull).Build();
			return "# Generated by STUWard\n# Unified server config for ward limit overrides and item prefab policy.\n#\n# item_prefab_policy.blocked_item_prefabs:\n#   Cannot be used, equipped, or attacked with inside a foreign enabled ward.\n#\n# item_prefab_policy.pickup_whitelist:\n#   Allowed when Pickup Block Mode = BlockAllExceptWhitelist.\n#\n# item_prefab_policy.pickup_blacklist:\n#   Blocked when Pickup Block Mode = AllowAllExceptBlacklist.\n#\n# ward_limit_overrides:\n#   Map Steam64 account ids to max ward counts.\n#   Use -1 for unlimited wards.\n\nward_limit_overrides:\n  # \"76561198000000000\": 6\n  # \"76561198000000001\": -1\n\n" + serializer.Serialize(graph);
		}

		private static ManagedWardConfigSnapshot CreateDefaultSnapshot()
		{
			return new ManagedWardConfigSnapshot(new Dictionary<string, int>(StringComparer.Ordinal), SerializeItemPrefabPolicy(CreateDefaultItemPrefabPolicy()));
		}

		private static ManagedWardItemPrefabPolicyYaml CreateDefaultItemPrefabPolicy()
		{
			return new ManagedWardItemPrefabPolicyYaml
			{
				BlockedItemPrefabs = new List<string> { "kg_TameableCollector", "PalStone", "PalStoneSpeed", "PalStoneArmour", "PalStoneHeal" },
				PickupWhitelist = new List<string> { "Wood" },
				PickupBlacklist = new List<string>()
			};
		}
	}
	internal readonly struct ManagedWardObservedState
	{
		internal bool Enabled { get; }

		internal uint DataRevision { get; }

		internal ManagedWardObservedState(bool enabled, uint dataRevision)
		{
			Enabled = enabled;
			DataRevision = dataRevision;
		}
	}
	internal readonly struct ManagedWardHoverTextCacheEntry
	{
		internal uint DataRevision { get; }

		internal string OriginalText { get; }

		internal long PlayerId { get; }

		internal bool CanConfigure { get; }

		internal bool CanAttemptAnyWardControl { get; }

		internal bool HasSettingsShortcutBinding { get; }

		internal string ShortcutLabel { get; }

		internal string GuildName { get; }

		internal string FinalText { get; }

		internal ManagedWardHoverTextCacheEntry(uint dataRevision, string originalText, long playerId, bool canConfigure, bool canAttemptAnyWardControl, bool hasSettingsShortcutBinding, string shortcutLabel, string guildName, string finalText)
		{
			DataRevision = dataRevision;
			OriginalText = originalText;
			PlayerId = playerId;
			CanConfigure = canConfigure;
			CanAttemptAnyWardControl = canAttemptAnyWardControl;
			HasSettingsShortcutBinding = hasSettingsShortcutBinding;
			ShortcutLabel = shortcutLabel;
			GuildName = guildName;
			FinalText = finalText;
		}

		internal bool Matches(ManagedWardHoverTextCacheEntry other)
		{
			if (DataRevision == other.DataRevision && string.Equals(OriginalText, other.OriginalText, StringComparison.Ordinal) && PlayerId == other.PlayerId && CanConfigure == other.CanConfigure && CanAttemptAnyWardControl == other.CanAttemptAnyWardControl && HasSettingsShortcutBinding == other.HasSettingsShortcutBinding && string.Equals(ShortcutLabel, other.ShortcutLabel, StringComparison.Ordinal))
			{
				return string.Equals(GuildName, other.GuildName, StringComparison.Ordinal);
			}
			return false;
		}

		internal ManagedWardHoverTextCacheEntry WithFinalText(string finalText)
		{
			return new ManagedWardHoverTextCacheEntry(DataRevision, OriginalText, PlayerId, CanConfigure, CanAttemptAnyWardControl, HasSettingsShortcutBinding, ShortcutLabel, GuildName, finalText);
		}
	}
	internal sealed class ManagedWardRuntimeContext
	{
		internal bool NetworkInitializationComplete;

		internal bool OwnershipObserved;

		internal bool HasNativeAreaMarkerSpeed;

		internal float NativeAreaMarkerSpeed;

		internal bool HasCachedConfiguration;

		internal CachedWardConfiguration CachedConfiguration;

		internal bool HasAreaMarkerVisualState;

		internal CachedAreaMarkerVisualState AreaMarkerVisualState;

		internal float AreaMarkerBoundaryFlashUntil = float.NegativeInfinity;

		internal float AreaMarkerPlacementHighlightUntil = float.NegativeInfinity;

		internal bool HasObservedState;

		internal ManagedWardObservedState ObservedState;

		internal bool HasPendingEnabledFanOutSuppression;

		internal bool PendingEnabledFanOutState;

		internal bool HasPendingDataRevisionFanOutSuppression;

		internal uint PendingDataRevisionFanOutBaseline;

		internal bool HasHoverText;

		internal ManagedWardHoverTextCacheEntry HoverText;

		internal float WarningEffectCooldownUntil;

		internal float PresenceLastTrustedNearbyTime = float.NegativeInfinity;

		internal void ClearConfigurationCaches()
		{
			HasCachedConfiguration = false;
			HasAreaMarkerVisualState = false;
		}

		internal void ClearAreaMarkerVisualState()
		{
			HasAreaMarkerVisualState = false;
		}

		internal void ClearObservedState()
		{
			HasObservedState = false;
			HasPendingEnabledFanOutSuppression = false;
			HasPendingDataRevisionFanOutSuppression = false;
		}

		internal void ClearHoverText()
		{
			HasHoverText = false;
		}

		internal void ResetPresenceState()
		{
			PresenceLastTrustedNearbyTime = float.NegativeInfinity;
		}
	}
	internal static class ManagedWardRuntimeContexts
	{
		private static readonly Dictionary<int, ManagedWardRuntimeContext> Contexts = new Dictionary<int, ManagedWardRuntimeContext>();

		internal static ManagedWardRuntimeContext GetOrCreate(PrivateArea area)
		{
			int instanceID = ((Object)area).GetInstanceID();
			if (!Contexts.TryGetValue(instanceID, out ManagedWardRuntimeContext value))
			{
				value = new ManagedWardRuntimeContext();
				Contexts[instanceID] = value;
			}
			return value;
		}

		internal static bool TryGet(PrivateArea? area, out ManagedWardRuntimeContext context)
		{
			context = null;
			if ((Object)(object)area != (Object)null)
			{
				return Contexts.TryGetValue(((Object)area).GetInstanceID(), out context);
			}
			return false;
		}

		internal static void Forget(PrivateArea? area)
		{
			if (!((Object)(object)area == (Object)null))
			{
				Contexts.Remove(((Object)area).GetInstanceID());
			}
		}

		internal static void Reset()
		{
			Contexts.Clear();
		}

		internal static void ClearConfigurationCaches()
		{
			foreach (ManagedWardRuntimeContext value in Contexts.Values)
			{
				value.ClearConfigurationCaches();
			}
		}

		internal static void ClearAreaMarkerVisualState(PrivateArea? area)
		{
			if (TryGet(area, out ManagedWardRuntimeContext context))
			{
				context.ClearAreaMarkerVisualState();
			}
		}

		internal static void ClearObservedState(PrivateArea? area)
		{
			if (TryGet(area, out ManagedWardRuntimeContext context))
			{
				context.ClearObservedState();
			}
		}

		internal static bool TryGetCurrentDataRevision(PrivateArea? area, out uint dataRevision)
		{
			dataRevision = 0u;
			if ((Object)(object)area == (Object)null)
			{
				return false;
			}
			ZDO zdo = WardPrivateAreaSafeAccess.GetZdo(area);
			if (zdo == null || !zdo.IsValid())
			{
				return false;
			}
			dataRevision = zdo.DataRevision;
			return true;
		}

		internal static void ArmNextEnabledFanOutSuppression(PrivateArea? area, bool expectedEnabled)
		{
			if (!((Object)(object)area == (Object)null))
			{
				ManagedWardRuntimeContext orCreate = GetOrCreate(area);
				orCreate.HasPendingEnabledFanOutSuppression = true;
				orCreate.PendingEnabledFanOutState = expectedEnabled;
			}
		}

		internal static void ArmNextDataRevisionFanOutSuppression(PrivateArea? area)
		{
			if (TryGetCurrentDataRevision(area, out var dataRevision))
			{
				ArmNextDataRevisionFanOutSuppression(area, dataRevision);
			}
		}

		internal static void ArmNextDataRevisionFanOutSuppression(PrivateArea? area, uint baselineDataRevision)
		{
			if (!((Object)(object)area == (Object)null))
			{
				ManagedWardRuntimeContext orCreate = GetOrCreate(area);
				orCreate.HasPendingDataRevisionFanOutSuppression = true;
				orCreate.PendingDataRevisionFanOutBaseline = baselineDataRevision;
			}
		}

		internal static bool TryConsumeEnabledFanOutSuppression(PrivateArea? area, bool currentEnabled)
		{
			if (!TryGet(area, out ManagedWardRuntimeContext context) || !context.HasPendingEnabledFanOutSuppression)
			{
				return false;
			}
			context.HasPendingEnabledFanOutSuppression = false;
			return context.PendingEnabledFanOutState == currentEnabled;
		}

		internal static bool TryConsumeDataRevisionFanOutSuppression(PrivateArea? area, uint currentDataRevision)
		{
			if (!TryGet(area, out ManagedWardRuntimeContext context) || !context.HasPendingDataRevisionFanOutSuppression)
			{
				return false;
			}
			context.HasPendingDataRevisionFanOutSuppression = false;
			return context.PendingDataRevisionFanOutBaseline != currentDataRevision;
		}

		internal static void ClearHoverText(PrivateArea? area)
		{
			if (TryGet(area, out ManagedWardRuntimeContext context))
			{
				context.ClearHoverText();
			}
		}

		internal static void ResetPresenceState(PrivateArea? area)
		{
			if (TryGet(area, out ManagedWardRuntimeContext context))
			{
				context.ResetPresenceState();
			}
		}

		internal static void ResetPresenceStates()
		{
			foreach (ManagedWardRuntimeContext value in Contexts.Values)
			{
				value.ResetPresenceState();
			}
		}
	}
	internal static class WardRuntimeStateTracker
	{
		internal static void Forget(PrivateArea? area)
		{
			ManagedWardRuntimeContexts.ClearObservedState(area);
		}

		internal static bool TryConsumeChanges(PrivateArea? area, out bool enabledChanged, out bool dataRevisionChanged)
		{
			enabledChanged = false;
			dataRevisionChanged = false;
			if (!TryBuildObservedState(area, out var state))
			{
				ManagedWardRuntimeContexts.ClearObservedState(area);
				return false;
			}
			ManagedWardRuntimeContext orCreate = ManagedWardRuntimeContexts.GetOrCreate(area);
			if (!orCreate.HasObservedState)
			{
				orCreate.ObservedState = state;
				orCreate.HasObservedState = true;
				return false;
			}
			ManagedWardObservedState observedState = orCreate.ObservedState;
			enabledChanged = observedState.Enabled != state.Enabled;
			dataRevisionChanged = observedState.DataRevision != state.DataRevision;
			if (!enabledChanged && !dataRevisionChanged)
			{
				return false;
			}
			orCreate.ObservedState = state;
			return true;
		}

		private static bool TryBuildObservedState(PrivateArea? area, out ManagedWardObservedState state)
		{
			state = default(ManagedWardObservedState);
			if ((Object)(object)area == (Object)null)
			{
				return false;
			}
			ZDO zdo = WardPrivateAreaSafeAccess.GetZdo(area);
			if (zdo == null)
			{
				return false;
			}
			state = new ManagedWardObservedState(area.IsEnabled(), zdo.DataRevision);
			return true;
		}
	}
	internal static class WardMinimapPinsManager
	{
		private enum ClientSnapshotState
		{
			Uninitialized,
			AwaitingFullSnapshot,
			Ready,
			TooLarge
		}

		private sealed class ServerViewerSyncState
		{
			internal readonly Dictionary<ZDOID, uint> VisibleWardDataRevisions = new Dictionary<ZDOID, uint>();

			internal DateTime LastSnapshotRequestUtc = DateTime.MinValue;

			internal int ViewerRevisionToken;

			internal bool HasSentFullSnapshot;

			internal bool SnapshotTooLarge;
		}

		private enum WardPinsResponseKind
		{
			Unavailable,
			FullSnapshot,
			Unchanged,
			TooLarge
		}

		private enum WardPinsPushKind
		{
			FullSnapshot,
			Delta,
			TooLarge
		}

		private const float DefaultSmallMapZoom = 0.01f;

		private static PinType WardIconPinType = (PinType)6;

		private static PinType WardRangePinType = (PinType)13;

		private static readonly TimeSpan RemoteSnapshotRequestInterval = TimeSpan.FromSeconds(0.5);

		private static readonly TimeSpan PendingSnapshotRetryInterval = TimeSpan.FromSeconds(2.0);

		private static readonly Dictionary<ZDOID, WardMinimapSnapshotEntry> LocalSnapshot = new Dictionary<ZDOID, WardMinimapSnapshotEntry>();

		private static readonly Dictionary<ZDOID, PinData> IconPins = new Dictionary<ZDOID, PinData>();

		private static readonly Dictionary<ZDOID, PinData> ActiveRangePins = new Dictionary<ZDOID, PinData>();

		private static bool _pendingForceRefresh;

		private static bool? _lastCanSeeAllWards;

		private static ClientSnapshotState _snapshotState = ClientSnapshotState.Uninitialized;

		private static int _lastViewerRevisionToken;

		private static int _nextSnapshotRequestId;

		private static int _pendingSnapshotRequestId;

		private static bool _snapshotTooLargeWarningLogged;

		private static DateTime _lastRemoteSnapshotRequestUtc = DateTime.MinValue;

		private static Minimap? _boundMinimap;

		private static Minimap? _customPinTypesMinimap;

		private static readonly TimeSpan ServerViewerRefreshDebounce = TimeSpan.FromMilliseconds(150.0);

		private static readonly TimeSpan MinimumServerSnapshotRequestInterval = TimeSpan.FromMilliseconds(250.0);

		private static readonly Dictionary<long, ServerViewerSyncState> ServerViewerSyncStatesByPeerUid = new Dictionary<long, ServerViewerSyncState>();

		private static readonly HashSet<long> PendingServerViewerRefreshPeerUids = new HashSet<long>();

		private static bool _pendingServerViewerRefreshForAll;

		private static DateTime _serverViewerRefreshFlushAtUtc = DateTime.MinValue;

		private const string RequestWardPinsRpc = "STUWard_RequestWardPins";

		private const string ReceiveWardPinsRpc = "STUWard_ReceiveWardPins";

		private const string PushWardPinsRpc = "STUWard_PushWardPins";

		private static bool _rpcsRegistered;

		internal static void ResetRuntimeState()
		{
			ResetClientRuntimeState();
			_rpcsRegistered = false;
			_pendingServerViewerRefreshForAll = false;
			ServerViewerSyncStatesByPeerUid.Clear();
			PendingServerViewerRefreshPeerUids.Clear();
			_serverViewerRefreshFlushAtUtc = DateTime.MinValue;
		}

		internal static void EnsureRuntimeBindings()
		{
			RegisterRpcs();
		}

		internal static void Update()
		{
			ProcessPendingServerViewerRefreshes();
		}

		internal static bool HasPendingRuntimeWork()
		{
			if (!_pendingServerViewerRefreshForAll)
			{
				return PendingServerViewerRefreshPeerUids.Count > 0;
			}
			return true;
		}

		internal static void NotifyWardDataMayHaveChanged(bool refreshImmediatelyIfVisible = false)
		{
			NotifyLocalWardDataMayHaveChanged(refreshImmediatelyIfVisible);
			QueueServerViewerRefreshRecipients(null);
		}

		internal static void HandleMapDataLoaded(Minimap? minimap)
		{
			if (!((Object)(object)minimap == (Object)null) && !((Object)(object)minimap != (Object)(object)Minimap.instance))
			{
				UpdateLocalState(Player.m_localPlayer, force: false, allowClosedMapRefresh: true);
			}
		}

		private static void ResetClientRuntimeState()
		{
			//IL_0051: 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)
			WardMapRangeSprites.Reset();
			ClearLocalPins(clearSnapshot: true);
			_pendingForceRefresh = false;
			_snapshotState = ClientSnapshotState.AwaitingFullSnapshot;
			_lastCanSeeAllWards = null;
			_lastViewerRevisionToken = 0;
			_nextSnapshotRequestId = 0;
			_pendingSnapshotRequestId = 0;
			_snapshotTooLargeWarningLogged = false;
			_lastRemoteSnapshotRequestUtc = DateTime.MinValue;
			_boundMinimap = null;
			_customPinTypesMinimap = null;
			WardIconPinType = (PinType)6;
			WardRangePinType = (PinType)13;
			LocalSnapshot.Clear();
			IconPins.Clear();
			ActiveRangePins.Clear();
		}

		internal static void HandleLocalConfigChanged()
		{
			UpdateLocalState(Player.m_localPlayer, force: false, allowClosedMapRefresh: true);
		}

		internal static void NotifyLocalWardDataMayHaveChanged(bool refreshImmediatelyIfVisible = false)
		{
			QueueForceRefresh();
			if (refreshImmediatelyIfVisible)
			{
				UpdateLocalState(Player.m_localPlayer, force: true, allowClosedMapRefresh: true);
			}
		}

		internal static void HandleMapModeChanged(Minimap? minimap, MapMode mode)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Invalid comparison between Unknown and I4
			if (!((Object)(object)minimap == (Object)null))
			{
				if (_boundMinimap != minimap)
				{
					_boundMinimap = minimap;
				}
				if ((int)mode == 2)
				{
					UpdateLocalState(Player.m_localPlayer, force: true);
				}
			}
		}

		internal static void UpdateLocalState(Player? player, bool force = false, bool allowClosedMapRefresh = false)
		{
			if ((Object)(object)player == (Object)null || (Object)(object)player != (Object)(object)Player.m_localPlayer)
			{
				return;
			}
			Minimap instance = Minimap.instance;
			if (_boundMinimap != instance)
			{
				ClearLocalPins(clearSnapshot: false);
				_boundMinimap = instance;
			}
			bool flag = WardAdminDebugAccess.IsPlayerAdminDebugController(player.GetPlayerID());
			if (!_lastCanSeeAllWards.HasValue || _lastCanSeeAllWards.Value != flag)
			{
				if (_lastCanSeeAllWards == true && !flag)
				{
					ClearLocalPins(clearSnapshot: true);
				}
				_lastCanSeeAllWards = flag;
				QueueRemoteSnapshotBootstrapRequest();
				_pendingForceRefresh = true;
				force = force || IsLargeMapOpen(instance);
			}
			_ = _pendingForceRefresh;
			if (!ShouldDisplayPins(player, flag))
			{
				ClearLocalPins(clearSnapshot: false);
				return;
			}
			RefreshLocalSnapshotIfNeeded(player, instance, flag, force, allowClosedMapRefresh);
			ApplySnapshotToMinimap(instance);
		}

		internal static void UpdatePendingRemoteState(Player? player)
		{
			if (!((Object)(object)player == (Object)null) && !((Object)(object)player != (Object)(object)Player.m_localPlayer) && IsLargeMapOpen(Minimap.instance) && (_pendingForceRefresh || (_snapshotState != ClientSnapshotState.Ready && _snapshotState != ClientSnapshotState.TooLarge) || _pendingSnapshotRequestId != 0))
			{
				UpdateLocalState(player);
			}
		}

		private static bool ShouldDisplayPins(Player player, bool canSeeAllWards)
		{
			bool num = GetWardPinScale() > 0;
			bool flag = Plugin.WardMinimapActiveRanges != null && Plugin.WardMinimapActiveRanges.Value == Plugin.Toggle.On;
			if (!num && !flag)
			{
				return false;
			}
			if (Game.m_noMap && !canSeeAllWards)
			{
				return false;
			}
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				return false;
			}
			if (ZDOMan.instance == null)
			{
				return false;
			}
			if ((Object)(object)player != (Object)(object)Player.m_localPlayer)
			{
				return false;
			}
			return true;
		}

		private static void RefreshLocalSnapshotIfNeeded(Player player, Minimap? minimap, bool canSeeAllWards, bool force, bool allowClosedMapRefresh)
		{
			if (allowClosedMapRefresh || IsLargeMapOpen(minimap))
			{
				if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
				{
					RefreshLocalSnapshotFromLocalIndex(player, canSeeAllWards, force);
				}
				else
				{
					RequestRemoteSnapshotIfNeeded(player, canSeeAllWards, force);
				}
			}
		}

		private static void RefreshLocalSnapshotFromLocalIndex(Player player, bool canSeeAllWards, bool force)
		{
			if (!WardMinimapVisibilityIndex.TryPrepare(ZDOMan.instance))
			{
				LocalSnapshot.Clear();
				_lastViewerRevisionToken = 0;
				QueueRemoteSnapshotBootstrapRequest();
				return;
			}
			long playerID = player.GetPlayerID();
			int playerGuildId = GuildsCompat.GetPlayerGuildId(playerID);
			int viewerRevisionToken = WardMinimapVisibilityIndex.GetViewerRevisionToken(playerID, playerGuildId, canSeeAllWards);
			if ((_snapshotState != ClientSnapshotState.TooLarge || _pendingForceRefresh || viewerRevisionToken != _lastViewerRevisionToken) && (force || _pendingForceRefresh || (_snapshotState != ClientSnapshotState.Ready && _snapshotState != ClientSnapshotState.TooLarge) || viewerRevisionToken != _lastViewerRevisionToken))
			{
				RebuildLocalSnapshot(playerID, playerGuildId, canSeeAllWards, viewerRevisionToken);
			}
		}

		private static void RequestRemoteSnapshotIfNeeded(Player player, bool canSeeAllWards, bool force)
		{
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Expected O, but got Unknown
			RegisterRpcs();
			if (_snapshotState == ClientSnapshotState.TooLarge && !_pendingForceRefresh)
			{
				return;
			}
			DateTime utcNow = DateTime.UtcNow;
			bool flag = _pendingSnapshotRequestId != 0 && utcNow - _lastRemoteSnapshotRequestUtc >= PendingSnapshotRetryInterval;
			bool flag2 = force || _pendingForceRefresh || _snapshotState != ClientSnapshotState.Ready || _lastViewerRevisionToken == 0;
			if (!(flag2 || flag))
			{
				return;
			}
			TimeSpan timeSpan = (force ? RemoteSnapshotRequestInterval : ((_pendingSnapshotRequestId != 0) ? PendingSnapshotRetryInterval : RemoteSnapshotRequestInterval));
			if (utcNow - _lastRemoteSnapshotRequestUtc < timeSpan)
			{
				return;
			}
			ZRoutedRpc instance = ZRoutedRpc.instance;
			if (instance != null)
			{
				int num = (_pendingSnapshotRequestId = (_nextSnapshotRequestId = ((_nextSnapshotRequestId == int.MaxValue) ? 1 : (_nextSnapshotRequestId + 1))));
				_lastRemoteSnapshotRequestUtc = utcNow;
				ZPackage val = new ZPackage();
				val.Write(num);
				int num2 = ((!flag2) ? _lastViewerRevisionToken : 0);
				val.Write(num2);
				val.Write(flag2);
				if (flag2)
				{
					QueueRemoteSnapshotBootstrapRequest();
				}
				instance.InvokeRoutedRPC("STUWard_RequestWardPins", new object[1] { val });
			}
		}

		private static void RebuildLocalSnapshot(long playerId, int playerGuildId, bool canSeeAllWards, int viewerRevisionToken)
		{
			WardMinimapViewerSnapshot wardMinimapViewerSnapshot = WardMinimapViewerSnapshotBuilder.Build(playerId, playerGuildId, canSeeAllWards, viewerRevisionToken, includeEntries: true, includeVisibleWardDataRevisions: false);
			if (wardMinimapViewerSnapshot.VisibleWardCount > 16384)
			{
				MarkLocalSnapshotTooLarge(viewerRevisionToken, wardMinimapViewerSnapshot.VisibleWardCount);
				return;
			}
			ReplaceLocalSnapshot(wardMinimapViewerSnapshot.Entries);
			_pendingSnapshotRequestId = 0;
			_lastViewerRevisionToken = viewerRevisionToken;
			_snapshotTooLargeWarningLogged = false;
			ClearPendingForceRefresh();
			ClearPendingRemoteSnapshotBootstrapRequest();
		}

		private static void MarkLocalSnapshotTooLarge(int viewerRevisionToken, int visibleWardCount)
		{
			_pendingSnapshotRequestId = 0;
			_lastViewerRevisionToken = viewerRevisionToken;
			_snapshotState = ClientSnapshotState.TooLarge;
			ClearPendingForceRefresh();
			if (!_snapshotTooLargeWarningLogged)
			{
				_snapshotTooLargeWarningLogged = true;
				Plugin.Log.LogWarning((object)$"Ward minimap snapshot has {visibleWardCount} visible wards, exceeding the supported limit of {16384}. Keeping the previous snapshot until it fits.");
			}
		}

		private static void ApplySnapshotToMinimap(Minimap? minimap)
		{
			//IL_006c: 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_00b5: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)minimap == (Object)null)
			{
				return;
			}
			bool flag = GetWardPinScale() > 0;
			bool flag2 = Plugin.WardMinimapActiveRanges != null && Plugin.WardMinimapActiveRanges.Value == Plugin.Toggle.On;
			Sprite pieceIcon = StuWardPrefab.GetPieceIcon();
			Sprite rangeIcon = (flag2 ? GetRepresentativeRangeSprite() : null);
			EnsureCustomPinTypes(minimap, pieceIcon, rangeIcon);
			HashSet<ZDOID> hashSet = new HashSet<ZDOID>();
			foreach (WardMinimapSnapshotEntry value in LocalSnapshot.Values)
			{
				hashSet.Add(value.ZdoId);
				if (flag)
				{
					UpsertIconPin(minimap, value, pieceIcon);
				}
				else
				{
					RemoveTrackedPin(minimap, IconPins, value.ZdoId);
				}
				if (flag2 && value.IsEnabled)
				{
					UpsertActiveRangePin(minimap, value);
				}
				else
				{
					RemoveTrackedPin(minimap, ActiveRangePins, value.ZdoId);
				}
			}
			RemoveMissingPins(minimap, IconPins, hashSet);
			RemoveMissingPins(minimap, ActiveRangePins, hashSet);
		}

		private static void UpsertIconPin(Minimap minimap, WardMinimapSnapshotEntry entry, Sprite? wardIcon)
		{
			//IL_0009: 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_006c: 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_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_0057: 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)
			bool flag = false;
			PinData value;
			bool flag2 = !IconPins.TryGetValue(entry.ZdoId, out value);
			if (!flag2 && !IsTrackedPinOnMinimap(minimap, value))
			{
				flag2 = true;
			}
			if (flag2)
			{
				value = minimap.AddPin(entry.Position, WardIconPinType, string.Empty, false, false, 0L, default(PlatformUserID));
				IconPins[entry.ZdoId] = value;
				flag = true;
			}
			if (value.m_pos != entry.Position)
			{
				value.m_pos = entry.Position;
				flag = true;
			}
			if (!value.m_doubleSize)
			{
				value.m_doubleSize = true;
				flag = true;
			}
			float iconWorldSize = GetIconWorldSize(minimap);
			if (iconWorldSize > 0f && !Mathf.Approximately(value.m_worldSize, iconWorldSize))
			{
				value.m_worldSize = iconWorldSize;
				flag = true;
			}
			if ((Object)(object)wardIcon != (Object)null && (Object)(object)value.m_icon != (Object)(object)wardIcon)
			{
				value.m_icon = wardIcon;
				flag = true;
			}
			if ((Object)(object)value.m_iconElement != (Object)null && (Object)(object)value.m_iconElement.sprite != (Object)(object)value.m_icon)
			{
				value.m_iconElement.sprite = value.m_icon;
				flag = true;
			}
			if (flag)
			{
				minimap.m_pinUpdateRequired = true;
			}
		}

		private static void UpsertActiveRangePin(Minimap minimap, WardMinimapSnapshotEntry entry)
		{
			//IL_0042: 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_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_0092: 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_00fe: 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_00d1: 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_00e7: 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_0113: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Max(0f, entry.Radius * 2f);
			Sprite val = ((num > 0f && !float.IsNaN(num) && !float.IsInfinity(num)) ? WardMapRangeSprites.GetRangeSprite() : null);
			bool flag = false;
			PinData value;
			bool flag2 = !ActiveRangePins.TryGetValue(entry.ZdoId, out value);
			if (!flag2 && !IsTrackedPinOnMinimap(minimap, value))
			{
				flag2 = true;
			}
			if (flag2)
			{
				value = minimap.AddPin(entry.Position, WardRangePinType, string.Empty, false, false, 0L, default(PlatformUserID));
				ActiveRangePins[entry.ZdoId] = value;
				flag = true;
			}
			else if (!Mathf.Approximately(value.m_worldSize, num))
			{
				minimap.RemovePin(value);
				value = minimap.AddPin(entry.Position, WardRangePinType, string.Empty, false, false, 0L, default(PlatformUserID));
				ActiveRangePins[entry.ZdoId] = value;
				flag = true;
			}
			if (value.m_pos != entry.Position)
			{
				value.m_pos = entry.Position;
				flag = true;
			}
			if (!Mathf.Approximately(value.m_worldSize, num))
			{
				value.m_worldSize = num;
				flag = true;
			}
			if ((Object)(object)val != (Object)null && (Object)(object)value.m_icon != (Object)(object)val)
			{
				value.m_icon = val;
				flag = true;
			}
			if ((Object)(object)value.m_iconElement != (Object)null && (Object)(object)value.m_iconElement.sprite != (Object)(object)value.m_icon)
			{
				value.m_iconElement.sprite = value.m_icon;
				flag = true;
			}
			if (flag)
			{
				minimap.m_pinUpdateRequired = true;
			}
		}

		private static bool IsTrackedPinOnMinimap(Minimap minimap, PinData pin)
		{
			if (pin != null && minimap.m_pins != null)
			{
				return minimap.m_pins.Contains(pin);
			}
			return false;
		}

		private static void RemoveMissingPins(Minimap minimap, Dictionary<ZDOID, PinData> pins, HashSet<ZDOID> seenWardIds)
		{
			//IL_0016: 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_005d: Unknown result type (might be due to invalid IL or missing references)
			List<ZDOID> list = null;
			foreach (KeyValuePair<ZDOID, PinData> pin in pins)
			{
				if (!seenWardIds.Contains(pin.Key))
				{
					if (list == null)
					{
						list = new List<ZDOID>();
					}
					list.Add(pin.Key);
				}
			}
			if (list != null)
			{
				for (int i = 0; i < list.Count; i++)
				{
					RemoveTrackedPin(minimap, pins, list[i]);
				}
			}
		}

		private static void RemoveTrackedPin(Minimap minimap, Dictionary<ZDOID, PinData> pins, ZDOID wardId)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if (pins.Remove(wardId, out PinData value))
			{
				minimap.RemovePin(value);
			}
		}

		private static void ClearLocalPins(bool clearSnapshot)
		{
			if ((Object)(object)_boundMinimap != (Object)null)
			{
				foreach (PinData value in IconPins.Values)
				{
					_boundMinimap.RemovePin(value);
				}
				foreach (PinData value2 in ActiveRangePins.Values)
				{
					_boundMinimap.RemovePin(value2);
				}
			}
			IconPins.Clear();
			ActiveRangePins.Clear();
			if (clearSnapshot)
			{
				_lastViewerRevisionToken = 0;
				_pendingSnapshotRequestId = 0;
				LocalSnapshot.Clear();
				QueueRemoteSnapshotBootstrapRequest();
			}
		}

		private static void ReplaceLocalSnapshot(IReadOnlyList<WardMinimapSnapshotEntry> snapshotEntries)
		{
			LocalSnapshot.Clear();
			UpsertLocalSnapshotEntries(snapshotEntries);
		}

		private static void UpsertLocalSnapshotEntries(IReadOnlyList<WardMinimapSnapshotEntry> snapshotEntries)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < snapshotEntries.Count; i++)
			{
				WardMinimapSnapshotEntry value = snapshotEntries[i];
				LocalSnapshot[value.ZdoId] = value;
			}
		}

		private static void ApplyLocalSnapshotDelta(IReadOnlyList<WardMinimapSnapshotEntry> snapshotEntries, IReadOnlyList<ZDOID> removedWardIds)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < removedWardIds.Count; i++)
			{
				LocalSnapshot.Remove(removedWardIds[i]);
			}
			UpsertLocalSnapshotEntries(snapshotEntries);
		}

		private static void QueueForceRefresh()
		{
			if (!_pendingForceRefresh)
			{
				_pendingForceRefresh = true;
			}
		}

		private static void QueueRemoteSnapshotBootstrapRequest()
		{
			_snapshotState = ClientSnapshotState.AwaitingFullSnapshot;
		}

		private static void ClearPendingRemoteSnapshotBootstrapRequest()
		{
			_snapshotState = ClientSnapshotState.Ready;
		}

		private static void ClearPendingForceRefresh()
		{
			_pendingForceRefresh = false;
		}

		private static void EnsureCustomPinTypes(Minimap minimap, Sprite? wardIcon, Sprite? rangeIcon)
		{
			//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_001a: 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_0027: 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_0041: 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_007e: Unknown result type (might be due to invalid IL or missing references)
			if (minimap.m_visibleIconTypes != null && minimap.m_icons != null)
			{
				if (_customPinTypesMinimap != minimap || !IsValidPinType(minimap, WardIconPinType) || !IsValidPinType(minimap, WardRangePinType) || !HasSpriteData(minimap, WardIconPinType) || !HasSpriteData(minimap, WardRangePinType))
				{
					WardIconPinType = AddCustomPinType(minimap, wardIcon);
					WardRangePinType = AddCustomPinType(minimap, rangeIcon ?? wardIcon);
					_customPinTypesMinimap = minimap;
				}
				else
				{
					UpdateCustomPinTypeSprite(minimap, WardIconPinType, wardIcon);
					UpdateCustomPinTypeSprite(minimap, WardRangePinType, rangeIcon ?? wardIcon);
				}
			}
		}

		private static PinType AddCustomPinType(Minimap minimap, Sprite? icon)
		{
			//IL_000a: 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)
			int num = minimap.m_visibleIconTypes.Length;
			PinType val = (PinType)num;
			ExpandVisibleIconTypes(minimap, num + 1);
			minimap.m_visibleIconTypes[num] = true;
			UpdateCustomPinTypeSprite(minimap, val, icon);
			return val;
		}

		private static void ExpandVisibleIconTypes(Minimap minimap, int requiredLength)
		{
			bool[] visibleIconTypes = minimap.m_visibleIconTypes;
			if (visibleIconTypes.Length < requiredLength)
			{
				bool[] array = new bool[requiredLength];
				Array.Copy(visibleIconTypes, array, visibleIconTypes.Length);
				for (int i = visibleIconTypes.Length; i < array.Length; i++)
				{
					array[i] = true;
				}
				minimap.m_visibleIconTypes = array;
			}
		}

		private static void UpdateCustomPinTypeSprite(Minimap minimap, PinType pinType, Sprite? icon)
		{
			//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_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_0058: 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_006e: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			List<SpriteData> icons = minimap.m_icons;
			if (icons == null)
			{
				return;
			}
			for (int i = 0; i < icons.Count; i++)
			{
				SpriteData val = icons[i];
				if (val.m_name == pinType)
				{
					if ((Object)(object)icon != (Object)null && (Object)(object)val.m_icon != (Object)(object)icon)
					{
						val.m_icon = icon;
						icons[i] = val;
					}
					return;
				}
			}
			icons.Add(new SpriteData
			{
				m_name = pinType,
				m_icon = icon
			});
		}

		private static bool IsValidPinType(Minimap minimap, PinType pinType)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Expected I4, but got Unknown
			int num = (int)pinType;
			if (minimap.m_visibleIconTypes != null && num >= 0)
			{
				return num < minimap.m_visibleIconTypes.Length;
			}
			return false;
		}

		private static bool HasSpriteData(Minimap minimap, PinType pinType)
		{
			//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)
			List<SpriteData> icons = minimap.m_icons;
			if (icons == null)
			{
				return false;
			}
			for (int i = 0; i < icons.Count; i++)
			{
				if (icons[i].m_name == pinType)
				{
					return true;
				}
			}
			return false;
		}

		private static Sprite? GetRepresentativeRangeSprite()
		{
			foreach (WardMinimapSnapshotEntry value in LocalSnapshot.Values)
			{
				if (value.IsEnabled)
				{
					return (value.Radius > 0f && !float.IsNaN(value.Radius) && !float.IsInfinity(value.Radius)) ? WardMapRangeSprites.GetRangeSprite() : null;
				}
			}
			return null;
		}

		private static float GetIconWorldSize(Minimap minimap)
		{
			//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)
			float num = minimap.m_pinSizeSmall * 2f;
			RawImage val = (((Object)(object)minimap.m_mapImageSmall != (Object)null) ? minimap.m_mapImageSmall : minimap.m_mapImageLarge);
			if (num <= 0f || (Object)(object)val == (Object)null)
			{
				return 0f;
			}
			float num2 = 0.01f;
			Rect rect = ((Graphic)val).rectTransform.rect;
			float height = ((Rect)(ref rect)).height;
			if (num2 <= 0f || height <= 0f)
			{
				return 0f;
			}
			int num3 = Mathf.Clamp(GetWardPinScale(), 0, 100);
			return num * (float)num3 * minimap.m_pixelSize * (float)minimap.m_textureSize * num2 / height;
		}

		private static int GetWardPinScale()
		{
			if (Plugin.WardMinimapPinScale == null)
			{
				return 1;
			}
			return Plugin.WardMinimapPinScale.Value;
		}

		private static bool IsLargeMapOpen(Minimap? minimap)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			if ((Object)(object)minimap != (Object)null)
			{
				return (int)minimap.m_mode == 2;
			}
			return false;
		}

		internal static void QueueServerViewerRefreshRecipients(HashSet<long>? recipientPeerUids)
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			if (recipientPeerUids == null)
			{
				_pendingServerViewerRefreshForAll = true;
				PendingServerViewerRefreshPeerUids.Clear();
			}
			else if (!_pendingServerViewerRefreshForAll)
			{
				foreach (long recipientPeerUid in recipientPeerUids)
				{
					if (recipientPeerUid != 0L)
					{
						PendingServerViewerRefreshPeerUids.Add(recipientPeerUid);
					}
				}
			}
			if (_serverViewerRefreshFlushAtUtc == DateTime.MinValue)
			{
				_serverViewerRefreshFlushAtUtc = DateTime.UtcNow + ServerViewerRefreshDebounce;
			}
		}

		private static void ProcessPendingServerViewerRefreshes()
		{
			if ((!_pendingServerViewerRefreshForAll && PendingServerViewerRefreshPeerUids.Count == 0) || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || _serverViewerRefreshFlushAtUtc > DateTime.UtcNow)
			{
				return;
			}
			List<ZNetPeer> peers = ZNet.instance.GetPeers();
			HashSet<long> hashSet = new HashSet<long>();
			HashSet<long> hashSet2 = new HashSet<long>();
			if (peers != null)
			{
				for (int i = 0; i < peers.Count; i++)
				{
					ZNetPeer val = peers[i];
					if (val != null && val.m_uid != 0L)
					{
						hashSet.Add(val.m_uid);
						long playerIdFromSender = WardOwnership.GetPlayerIdFromSender(val.m_uid);
						if (playerIdFromSender != 0L)
						{
							hashSet2.Add(playerIdFromSender);
						}
					}
				}
			}
			AddActivePlayerIds(hashSet2);
			PruneServerViewerSyncStates(hashSet);
			if (hashSet2.Count > 0 || hashSet.Count == 0)
			{
				WardMinimapVisibilityIndex.PruneViewerCaches(hashSet2);
			}
			List<long> list = new List<long>();
			if (_pendingServerViewerRefreshForAll)
			{
				list.AddRange(hashSet);
			}
			else
			{
				foreach (long pendingServerViewerRefreshPeerUid in PendingServerViewerRefreshPeerUids)
				{
					if (hashSet.Contains(pendingServerViewerRefreshPeerUid))
					{
						list.Add(pendingServerViewerRefreshPeerUid);
					}
				}
			}
			if (list.Count == 0)
			{
				_pendingServerViewerRefreshForAll = false;
				PendingServerViewerRefreshPeerUids.Clear();
				_serverViewerRefreshFlushAtUtc = DateTime.MinValue;
				return;
			}
			if (!WardMinimapVisibilityIndex.TryPrepare(ZDOMan.instance))
			{
				_serverViewerRefreshFlushAtUtc = DateTime.UtcNow + ServerViewerRefreshDebounce;
				return;
			}
			_pendingServerViewerRefreshForAll = false;
			PendingServerViewerRefreshPeerUids.Clear();
			_serverViewerRefreshFlushAtUtc = DateTime.MinValue;
			for (int j = 0; j < list.Count; j++)
			{
				PushWardPinsUpdateToPeer(list[j]);
			}
		}

		private static void AddActivePlayerIds(HashSet<long> activePlayerIds)
		{
			List<Player> allPlayers = Player.GetAllPlayers();
			if (allPlayers == null || allPlayers.Count == 0)
			{
				return;
			}
			for (int i = 0; i < allPlayers.Count; i++)
			{
				Player val = allPlayers[i];
				if (!((Object)(object)val == (Object)null))
				{
					long playerID = val.GetPlayerID();
					if (playerID != 0L)
					{
						activePlayerIds.Add(playerID);
					}
				}
			}
		}

		private static void PruneServerViewerSyncStates(HashSet<long> livePeerUids)
		{
			List<long> list = null;
			foreach (KeyValuePair<long, ServerViewerSyncState> item in ServerViewerSyncStatesByPeerUid)
			{
				if (!livePeerUids.Contains(item.Key))
				{
					if (list == null)
					{
						list = new List<long>();
					}
					list.Add(item.Key);
				}
			}
			if (list != null)
			{
				for (int i = 0; i < list.Count; i++)
				{
					ServerViewerSyncStatesByPeerUid.Remove(list[i]);
				}
			}
		}

		private static void PushWardPinsUpdateToPeer(long receiverUid)
		{
			if (TryBuildServerViewerSyncUpdate(receiverUid, out WardPinsPushKind pushKind, out int viewerRevisionToken, out long playerId, out bool canSeeAllWards, out int indexedWardCount, out int candidateWardCount, out int visibleWardCount, out int enabledWardCount, out IReadOnlyList<WardMinimapSnapshotEntry> snapshotEntries, out IReadOnlyList<ZDOID> removedWardIds))
			{
				SendWardPinsPush(receiverUid, pushKind, viewerRevisionToken, playerId, canSeeAllWards, indexedWardCount, candidateWardCount, visibleWardCount, enabledWardCount, snapshotEntries, removedWardIds);
			}
		}

		private static bool TryBuildServerViewerSyncUpdate(long receiverUid, out WardPinsPushKind pushKind, out int viewerRevisionToken, out long playerId, out bool canSeeAllWards, out int indexedWardCount, out int candidateWardCount, out int visibleWardCount, out int enabledWardCount, out IReadOnlyList<WardMinimapSnapshotEntry> snapshotEntries, out IReadOnlyList<ZDOID> removedWardIds)
		{
			//IL_00f8: 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_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			pushKind = WardPinsPushKind.Delta;
			viewerRevisionToken = 0;
			playerId = 0L;
			canSeeAllWards = false;
			indexedWardCount = 0;
			candidateWardCount = 0;
			visibleWardCount = 0;
			enabledWardCount = 0;
			snapshotEntries = Array.Empty<WardMinimapSnapshotEntry>();
			removedWardIds = Array.Empty<ZDOID>();
			playerId = WardOwnership.GetPlayerIdFromSender(receiverUid);
			if (playerId == 0L)
			{
				return false;
			}
			canSeeAllWards = playerId != 0L && WardAdminDebugAccess.IsPlayerAdminDebugController(playerId);
			int playerGuildId = GuildsCompat.GetPlayerGuildId(playerId);
			viewerRevisionToken = WardMinimapVisibilityIndex.GetViewerRevisionToken(playerId, playerGuildId, canSeeAllWards);
			WardMinimapViewerSnapshot wardMinimapViewerSnapshot = WardMinimapViewerSnapshotBuilder.Build(playerId, playerGuildId, canSeeAllWards, viewerRevisionToken, includeEntries: true, includeVisibleWardDataRevisions: true);
			indexedWardCount = wardMinimapViewerSnapshot.IndexedWardCount;
			candidateWardCount = wardMinimapViewerSnapshot.CandidateWardCount;
			visibleWardCount = wardMinimapViewerSnapshot.VisibleWardCount;
			enabledWardCount = wardMinimapViewerSnapshot.EnabledWardCount;
			ServerViewerSyncState orCreateServerViewerSyncState = GetOrCreateServerViewerSyncState(receiverUid);
			if ((orCreateServerViewerSyncState.HasSentFullSnapshot || orCreateServerViewerSyncState.SnapshotTooLarge) && orCreateServerViewerSyncState.ViewerRevisionToken == viewerRevisionToken)
			{
				return false;
			}
			if (wardMinimapViewerSnapshot.VisibleWardCount > 16384)
			{
				pushKind = WardPinsPushKind.TooLarge;
				TrackServerViewerSnapshotTooLarge(receiverUid, viewerRevisionToken);
				return true;
			}
			List<WardMinimapSnapshotEntry> list = null;
			for (int i = 0; i < wardMinimapViewerSnapshot.Entries.Count; i++)
			{
				WardMinimapSnapshotEntry item = wardMinimapViewerSnapshot.Entries[i];
				uint value;
				uint num = (wardMinimapViewerSnapshot.VisibleWardDataRevisions.TryGetValue(item.ZdoId, out value) ? value : 0u);
				if (!orCreateServerViewerSyncState.HasSentFullSnapshot || !orCreateServerViewerSyncState.VisibleWardDataRevisions.TryGetValue(item.ZdoId, out var value2) || value2 != num)
				{
					if (list == null)
					{
						list = new List<WardMinimapSnapshotEntry>();
					}
					list.Add(item);
				}
			}
			List<ZDOID> list2 = null;
			if (orCreateServerViewerSyncState.HasSentFullSnapshot && orCreateServerViewerSyncState.VisibleWardDataRevisions.Count > 0)
			{
				foreach (KeyValuePair<ZDOID, uint> visibleWardDataRevision in orCreateServerViewerSyncState.VisibleWardDataRevisions)
				{
					if (!wardMinimapViewerSnapshot.VisibleWardDataRevisions.ContainsKey(visibleWardDataRevision.Key))
					{
						if (list2 == null)
						{
							list2 = new List<ZDOID>();
						}
						list2.Add(visibleWardDataRevision.Key);
					}
				}
			}
			int num2 = list?.Count ?? 0;
			int num3 = list2?.Count ?? 0;
			bool flag = !orCreateServerViewerSyncState.HasSentFullSnapshot || ShouldSendFullSnapshot(num2, num3, wardMinimapViewerSnapshot.VisibleWardCount) || num2 + num3 > 16384;
			if (!flag && num2 == 0 && num3 == 0)
			{
				UpdateServerViewerSyncState(orCreateServerViewerSyncState, viewerRevisionToken, wardMinimapViewerSnapshot.VisibleWardDataRevisions);
				return false;
			}
			IReadOnlyList<WardMinimapSnapshotEntry> readOnlyList2;
			if (!flag)
			{
				if (list != null && list.Count != 0)
				{
					IReadOnlyList<WardMinimapSnapshotEntry> readOnlyList = list;
					readOnlyList2 = readOnlyList;
				}
				else
				{
					IReadOnlyList<WardMinimapSnapshotEntry> readOnlyList = Array.Empty<WardMinimapSnapshotEntry>();
					readOnlyList2 = readOnlyList;
				}
			}
			else
			{
				readOnlyList2 = wardMinimapViewerSnapshot.Entries;
			}
			snapshotEntries = readOnlyList2;
			IReadOnlyList<ZDOID> readOnlyList4;
			if (!flag && list2 != null && list2.Count != 0)
			{
				IReadOnlyList<ZDOID> readOnlyList3 = list2;
				readOnlyList4 = readOnlyList3;
			}
			else
			{
				IReadOnlyList<ZDOID> readOnlyList3 = Array.Empty<ZDOID>();
				readOnlyList4 = readOnlyList3;
			}
			removedWardIds = readOnlyList4;
			pushKind = ((!flag) ? WardPinsPushKind.Delta : WardPinsPushKind.FullSnapshot);
			UpdateServerViewerSyncState(orCreateServerViewerSyncState, viewerRevisionToken, wardMinimapViewerSnapshot.VisibleWardDataRevisions);
			return true;
		}

		private static ServerViewerSyncState GetOrCreateServerViewerSyncState(long receiverUid)
		{
			if (!ServerViewerSyncStatesByPeerUid.TryGetValue(receiverUid, out ServerViewerSyncState value))
			{
				value = new ServerViewerSyncState();
				ServerViewerSyncStatesByPeerUid[receiverUid] = value;
			}
			return value;
		}

		private static bool TryBeginServerSnapshotRequest(long receiverUid)
		{
			DateTime utcNow = DateTime.UtcNow;
			ServerViewerSyncState orCreateServerViewerSyncState = GetOrCreateServerViewerSyncState(receiverUid);
			if (orCreateServerViewerSyncState.LastSnapshotRequestUtc != DateTime.MinValue && utcNow >= orCreateServerViewerSyncState.LastSnapshotRequestUtc && utcNow - orCreateServerViewerSyncState.LastSnapshotRequestUtc < MinimumServerSnapshotRequestInterval)
			{
				return false;
			}
			orCreateServerViewerSyncState.LastSnapshotRequestUtc = utcNow;
			return true;
		}

		private static void UpdateServerViewerSyncState(ServerViewerSyncState syncState, int viewerRevisionToken, IReadOnlyDictionary<ZDOID, uint> currentVisibleWardRevisions)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			syncState.VisibleWardDataRevisions.Clear();
			foreach (KeyValuePair<ZDOID, uint> currentVisibleWardRevision in currentVisibleWardRevisions)
			{
				syncState.VisibleWardDataRevisions[currentVisibleWardRevision.Key] = currentVisibleWardRevision.Value;
			}
			syncState.ViewerRevisionToken = viewerRevisionToken;
			syncState.HasSentFullSnapshot = true;
			syncState.SnapshotTooLarge = false;
		}

		private static bool ShouldSendFullSnapshot(int changedEntryCount, int removedEntryCount, int visibleWardCount)
		{
			if (visibleWardCount <= 0)
			{
				return removedEntryCount > 0;
			}
			return changedEntryCount + removedEntryCount >= visibleWardCount;
		}

		private static void TrackServerViewerSyncState(long receiverUid, WardMinimapViewerSnapshot snapshot)
		{
			if (receiverUid != 0L && snapshot.ViewerRevisionToken != 0)
			{
				UpdateServerViewerSyncState(GetOrCreateServerViewerSyncState(receiverUid), snapshot.ViewerRevisionToken, snapshot.VisibleWardDataRevisions);
			}
		}

		private static void TrackServerViewerSnapshotTooLarge(long receiverUid, int viewerRevisionToken)
		{
			if (receiverUid != 0L)
			{
				ServerViewerSyncState orCreateServerViewerSyncState = GetOrCreateServerViewerSyncState(receiverUid);
				orCreateServerViewerSyncState.VisibleWardDataRevisions.Clear();
				orCreateServerViewerSyncState.ViewerRevisionToken = viewerRevisionToken;
				orCreateServerViewerSyncState.HasSentFullSnapshot = false;
				orCreateServerViewerSyncState.SnapshotTooLarge = true;
			}
		}

		internal static void RegisterRpcs()
		{
			ZRoutedRpc instance = ZRoutedRpc.instance;
			if (!_rpcsRegistered && instance != null)
			{
				instance.Register<ZPackage>("STUWard_RequestWardPins", (Action<long, ZPackage>)HandleRequestWardPins);
				instance.Register<ZPackage>("STUWard_ReceiveWardPins", (Action<long, ZPackage>)HandleReceiveWardPins);
				instance.Register<ZPackage>("STUWard_PushWardPins", (Action<long, ZPackage>)HandlePushWardPins);
				_rpcsRegistered = true;
			}
		}

		private static void HandleRequestWardPins(long sender, ZPackage pkg)
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			int num;
			int num2;
			bool flag;
			try
			{
				num = ((pkg != null) ? pkg.ReadInt() : 0);
				num2 = ((pkg != null) ? pkg.ReadInt() : 0);
				flag = pkg != null && pkg.ReadBool();
			}
			catch
			{
				return;
			}
			if (num <= 0 || pkg == null || !WardOwnership.TryResolveAuthoritativePlayerIdFromSender(sender, out var playerId) || !TryBeginServerSnapshotRequest(sender))
			{
				return;
			}
			bool canSeeAllWards = WardAdminDebugAccess.IsPlayerAdminDebugController(playerId);
			int playerGuildId = GuildsCompat.GetPlayerGuildId(playerId);
			bool num3 = WardMinimapVisibilityIndex.TryPrepare(ZDOMan.instance);
			WardPinsResponseKind responseKind = WardPinsResponseKind.Unavailable;
			WardMinimapViewerSnapshot snapshot = WardMinimapViewerSnapshot.Empty;
			if (num3)
			{
				int viewerRevisionToken = WardMinimapVisibilityIndex.GetViewerRevisionToken(playerId, playerGuildId, canSeeAllWards);
				bool flag2 = flag || num2 == 0 || viewerRevisionToken != num2;
				snapshot = WardMinimapViewerSnapshotBuilder.Build(playerId, playerGuildId, canSeeAllWards, viewerRevisionToken, flag2, includeVisibleWardDataRevisions: true);
				if (snapshot.VisibleWardCount > 16384)
				{
					responseKind = WardPinsResponseKind.TooLarge;
					TrackServerViewerSnapshotTooLarge(sender, snapshot.ViewerRevisionToken);
				}
				else
				{
					responseKind = (flag2 ? WardPinsResponseKind.FullSnapshot : WardPinsResponseKind.Unchanged);
					TrackServerViewerSyncState(sender, snapshot);
				}
			}
			SendWardPinsResponse(sender, num, responseKind, playerId, canSeeAllWards, snapshot);
		}

		private static void SendWardPinsResponse(long receiverUid, int requestId, WardPinsResponseKind responseKind, long playerId, bool canSeeAllWards, WardMinimapViewerSnapshot snapshot)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			ZRoutedRpc instance = ZRoutedRpc.instance;
			if (instance == null || receiverUid == 0L)
			{
				return;
			}
			IReadOnlyList<WardMinimapSnapshotEntry> readOnlyList = Array.Empty<WardMinimapSnapshotEntry>();
			if (responseKind == WardPinsResponseKind.FullSnapshot)
			{
				if (snapshot.Entries.Count > 16384)
				{
					responseKind = WardPinsResponseKind.TooLarge;
					TrackServerViewerSnapshotTooLarge(receiverUid, snapshot.ViewerRevisionToken);
				}
				else if (!AreSnapshotEntriesValid(snapshot.Entries))
				{
					responseKind = WardPinsResponseKind.Unavailable;
				}
				else
				{
					readOnlyList = snapshot.Entries;
				}
			}
			ZPackage val = new ZPackage();
			val.Write(requestId);
			val.Write((int)responseKind);
			val.Write(snapshot.ViewerRevisionToken);
			val.Write(playerId);
			val.Write(canSeeAllWards);
			val.Write(snapshot.IndexedWardCount);
			val.Write(snapshot.CandidateWardCount);
			val.Write(snapshot.VisibleWardCount);
			val.Write(snapshot.EnabledWardCount);
			val.Write(readOnlyList.Count);
			WriteSnapshotEntries(val, readOnlyList);
			instance.InvokeRoutedRPC(receiverUid, "STUWard_ReceiveWardPins", new object[1] { val });
		}

		private static void SendWardPinsPush(long receiverUid, WardPinsPushKind pushKind, int viewerRevisionToken, long playerId, bool canSeeAllWards, int indexedWardCount, int candidateWardCount, int visibleWardCount, int enabledWardCount, IReadOnlyList<WardMinimapSnapshotEntry> snapshotEntries, IReadOnlyList<ZDOID> removedWardIds)
		{
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Expected O, but got Unknown
			ZRoutedRpc instance = ZRoutedRpc.instance;
			if (instance == null || receiverUid == 0L)
			{
				return;
			}
			int count = snapshotEntries.Count;
			int count2 = removedWardIds.Count;
			if (pushKind != WardPinsPushKind.TooLarge && visibleWardCount > 16384)
			{
				pushKind = WardPinsPushKind.TooLarge;
				snapshotEntries = Array.Empty<WardMinimapSnapshotEntry>();
				removedWardIds = Array.Empty<ZDOID>();
				TrackServerViewerSnapshotTooLarge(receiverUid, viewerRevisionToken);
			}
			else if (pushKind == WardPinsPushKind.TooLarge)
			{
				if (visibleWardCount <= 16384)
				{
					Plugin.Log.LogError((object)"Refusing to send an invalid ward minimap TooLarge response.");
					return;
				}
				snapshotEntries = Array.Empty<WardMinimapSnapshotEntry>();
				removedWardIds = Array.Empty<ZDOID>();
			}
			else
			{
				if (count > 16384 || count2 > 16384 - count)
				{
					Plugin.Log.LogError((object)"Refusing to send an oversized ward minimap snapshot payload.");
					return;
				}
				if (!AreSnapshotEntriesValid(snapshotEntries) || !AreRemovedWardIdsValid(removedWardIds))
				{
					Plugin.Log.LogError((object)"Refusing to send an invalid ward minimap snapshot payload.");
					return;
				}
			}
			ZPackage val = new ZPackage();
			val.Write((int)pushKind);
			val.Write(viewerRevisionToken);
			val.Write(playerId);
			val.Write(canSeeAllWards);
			val.Write(indexedWardCount);
			val.Write(candidateWardCount);
			val.Write(visibleWardCount);
			val.Write(enabledWardCount);
			val.Write(snapshotEntries.Count);
			WriteSnapshotEntries(val, snapshotEntries);
			val.Write(removedWardIds.Count);
			WriteRemovedWardIds(val, removedWardIds);
			instance.InvokeRoutedRPC(receiverUid, "STUWard_PushWardPins", new object[1] { val });
		}

		private static void HandleReceiveWardPins(long sender, ZPackage pkg)
		{
			if (!WardOwnership.IsAuthoritativeServerSender(sender) || pkg == null)
			{
				return;
			}
			int num;
			WardPinsResponseKind responseKind;
			int num2;
			int num3;
			int num4;
			try
			{
				num = pkg.ReadInt();
				if (!TryReadWardPinsResponseKind(pkg.ReadInt(), out responseKind))
				{
					return;
				}
				num2 = pkg.ReadInt();
				pkg.ReadLong();
				pkg.ReadBool();
				pkg.ReadInt();
				pkg.ReadInt();
				num3 = pkg.ReadInt();
				pkg.ReadInt();
				num4 = pkg.ReadInt();
			}
			catch
			{
				return;
			}
			if (num <= 0 || (_lastViewerRevisionToken != 0 && num2 != 0 && num2 < _lastViewerRevisionToken) || _pendingSnapshotRequestId == 0 || num != _pendingSnapshotRequestId)
			{
				return;
			}
			if (responseKind != WardPinsResponseKind.TooLarge && (num3 < 0 || num3 > 16384))
			{
				QueueRemoteSnapshotBootstrapRequest();
				return;
			}
			switch (responseKind)
			{
			case WardPinsResponseKind.Unavailable:
				if (num4 != 0)
				{
					QueueRemoteSnapshotBootstrapRequest();
				}
				break;
			case WardPinsResponseKind.TooLarge:
				if (num4 != 0 || num3 <= 16384)
				{
					QueueRemoteSnapshotBootstrapRequest();
					break;
				}
				MarkLocalSnapshotTooLarge(num2, num3);
				UpdateLocalState(Player.m_localPlayer);
				break;
			case WardPinsResponseKind.Unchanged:
				if (num4 != 0)
				{
					QueueRemoteSnapshotBootstrapRequest();
				}
				else if (_snapshotState != ClientSnapshotState.Ready)
				{
					_pendingSnapshotRequestId = 0;
					_lastViewerRevisionToken = 0;
					QueueRemoteSnapshotBootstrapRequest();
					UpdateLocalState(Player.m_localPlayer);
				}
				else
				{
					ClearPendingForceRefresh();
					ClearPendingRemoteSnapshotBootstrapRequest();
					_pendingSnapshotRequestId = 0;
					_lastViewerRevisionToken = num2;
					UpdateLocalState(Player.m_localPlayer);
				}
				break;
			default:
			{
				if (num3 < 0 || num4 != num3 || !TryReadSnapshotEntries(pkg, num4, out WardMinimapSnapshotEntry[] snapshotEntries))
				{
					QueueRemoteSnapshotBootstrapRequest();
					break;
				}
				ReplaceLocalSnapshot(snapshotEntries);
				ClearPendingForceRefresh();
				ClearPendingRemoteSnapshotBootstrapRequest();
				_pendingSnapshotRequestId = 0;
				_lastViewerRevisionToken = num2;
				UpdateLocalState(Player.m_localPlayer);
				break;
			}
			}
		}

		private static bool TryReadWardPinsResponseKind(int rawValue, out WardPinsResponseKind responseKind)
		{
			if ((uint)rawValue <= 3u)
			{
				responseKind = (WardPinsResponseKind)rawValue;
				return true;
			}
			responseKind = WardPinsResponseKind.Unavailable;
			return false;
		}

		private static void HandlePushWardPins(long sender, ZPackage pkg)
		{
			if (!WardOwnership.IsAuthoritativeServerSender(sender) || pkg == null)
			{
				return;
			}
			WardPinsPushKind pushKind;
			int num;
			int num2;
			int num3;
			try
			{
				if (!TryReadWardPinsPushKind(pkg.ReadInt(), out pushKind))
				{
					QueueRemoteSnapshotBootstrapRequest();
					return;
				}
				num = pkg.ReadInt();
				pkg.ReadLong();
				pkg.ReadBool();
				pkg.ReadInt();
				pkg.ReadInt();
				num2 = pkg.ReadInt();
				pkg.ReadInt();
				num3 = pkg.ReadInt();
			}
			catch
			{
				QueueRemoteSnapshotBootstrapRequest();
				return;
			}
			if (_lastViewerRevisionToken != 0 && num != 0 && num < _lastViewerRevisionToken)
			{
				return;
			}
			if (!TryReadSnapshotEntries(pkg, num3, out WardMinimapSnapshotEntry[] snapshotEntries))
			{
				QueueRemoteSnapshotBootstrapRequest();
				return;
			}
			int num4;
			try
			{
				num4 = pkg.ReadInt();
			}
			catch
			{
				QueueRemoteSnapshotBootstrapRequest();
				return;
			}
			if (!TryReadRemovedWardIds(pkg, num4, out ZDOID[] removedWardIds))
			{
				QueueRemoteSnapshotBootstrapRequest();
				return;
			}
			if (num3 > 16384 - num4)
			{
				QueueRemoteSnapshotBootstrapRequest();
				return;
			}
			if (pushKind != WardPinsPushKind.TooLarge && (num2 < 0 || num2 > 16384))
			{
				QueueRemoteSnapshotBootstrapRequest();
				return;
			}
			switch (pushKind)
			{
			case WardPinsPushKind.TooLarge:
				if (num3 != 0 || num4 != 0 || num2 <= 16384)
				{
					QueueRemoteSnapshotBootstrapRequest();
					return;
				}
				MarkLocalSnapshotTooLarge(num, num2);
				UpdateLocalState(Player.m_localPlayer);
				return;
			case WardPinsPushKind.Delta:
				if (_snapshotState != ClientSnapshotState.Ready)
				{
					QueueRemoteSnapshotBootstrapRequest();
					return;
				}
				break;
			}
			if (pushKind == WardPinsPushKind.FullSnapshot)
			{
				if (num4 != 0 || num2 < 0 || num3 != num2)
				{
					QueueRemoteSnapshotBootstrapRequest();
					return;
				}
				ReplaceLocalSnapshot(snapshotEntries);
			}
			else
			{
				ApplyLocalSnapshotDelta(snapshotEntries, removedWardIds);
			}
			ClearPendingForceRefresh();
			ClearPendingRemoteSnapshotBootstrapRequest();
			_pendingSnapshotRequestId = 0;
			_lastViewerRevisionToken = num;
			UpdateLocalState(Player.m_localPlayer);
		}

		private static bool TryReadWardPinsPushKind(int rawValue, out WardPinsPushKind pushKind)
		{
			if ((uint)rawValue <= 2u)
			{
				pushKind = (WardPinsPushKind)rawValue;
				return true;
			}
			pushKind = WardPinsPushKind.Delta;
			return false;
		}

		private static void WriteSnapshotEntries(ZPackage pkg, IReadOnlyList<WardMinimapSnapshotEntry> snapshotEntries)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < snapshotEntries.Count; i++)
			{
				WardMinimapSnapshotEntry wardMinimapSnapshotEntry = snapshotEntries[i];
				pkg.Write(wardMinimapSnapshotEntry.ZdoId);
				pkg.Write(wardMinimapSnapshotEntry.Position);
				pkg.Write(wardMinimapSnapshotEntry.Radius);
				pkg.Write(wardMinimapSnapshotEntry.IsEnabled);
			}
		}

		private static void WriteRemovedWardIds(ZPackage pkg, IReadOnlyList<ZDOID> removedWardIds)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < removedWardIds.Count; i++)
			{
				pkg.Write(removedWardIds[i]);
			}
		}

		private static bool TryReadSnapshotEntries(ZPackage pkg, int snapshotCount, out WardMinimapSnapshotEntry[] snapshotEntries)
		{
			//IL_002f: 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)
			if (snapshotCount < 0 || snapshotCount > 16384)
			{
				snapshotEntries = Array.Empty<WardMinimapSnapshotEntry>();
				return false;
			}
			snapshotEntries = ((snapshotCount <= 0) ? Array.Empty<WardMinimapSnapshotEntry>() : new WardMinimapSnapshotEntry[snapshotCount]);
			try
			{
				for (int i = 0; i < snapshotEntries.Length; i++)
				{
					WardMinimapSnapshotEntry wardMinimapSnapshotEntry = new WardMinimapSnapshotEntry(pkg.ReadZDOID(), pkg.ReadVector3(), pkg.ReadSingle(), pkg.ReadBool());
					if (!WardMinimapSnapshotProtocol.IsValidEntry(wardMinimapSnapshotEntry))
					{
						snapshotEntries = Array.Empty<WardMinimapSnapshotEntry>();
						return false;
					}
					snapshotEntries[i] = wardMinimapSnapshotEntry;
				}
				return true;
			}
			catch
			{
				snapshotEntries = Array.Empty<WardMinimapSnapshotEntry>();
				return false;
			}
		}

		private static bool TryReadRemovedWardIds(ZPackage pkg, int removedWardCount, out ZDOID[] removedWardIds)
		{
			//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_004a: 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)
			if (removedWardCount < 0 || removedWardCount > 16384)
			{
				removedWardIds = Array.Empty<ZDOID>();
				return false;
			}
			removedWardIds = (ZDOID[])((removedWardCount <= 0) ? ((Array)Array.Empty<ZDOID>()) : ((Array)new ZDOID[removedWardCount]));
			try
			{
				for (int i = 0; i < removedWardIds.Length; i++)
				{
					ZDOID val = pkg.ReadZDOID();
					if (((ZDOID)(ref val)).IsNone())
					{
						removedWardIds = Array.Empty<ZDOID>();
						return false;
					}
					removedWardIds[i] = val;
				}
				return true;
			}
			catch
			{
				removedWardIds = Array.Empty<ZDOID>();
				return false;
			}
		}

		private static bool AreSnapshotEntriesValid(IReadOnlyList<WardMinimapSnapshotEntry> snapshotEntries)
		{
			for (int i = 0; i < snapshotEntries.Count; i++)
			{
				if (!WardMinimapSnapshotProtocol.IsValidEntry(snapshotEntries[i]))
				{
					return false;
				}
			}
			return true;
		}

		private static bool AreRemovedWardIdsValid(IReadOnlyList<ZDOID> removedWardIds)
		{
			//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)
			for (int i = 0; i < removedWardIds.Count; i++)
			{
				ZDOID val = removedWardIds[i];
				if (((ZDOID)(ref val)).IsNone())
				{
					return false;
				}
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Minimap), "SetMapData")]
	internal static class MinimapSetMapDataWardPinsPatch
	{
		private static void Postfix(Minimap __instance)
		{
			WardMinimapPinsManager.HandleMapDataLoaded(__instance);
		}
	}
	[HarmonyPatch(typeof(Minimap), "SetMapMode")]
	internal static class MinimapSetMapModeWardPinsPatch
	{
		private static void Postfix(Minimap __instance, MapMode mode)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			WardMinimapPinsManager.HandleMapModeChanged(__instance, mode);
		}
	}
	[HarmonyPatch(typeof(Player), "Update")]
	internal static class PlayerUpdateWardPinsPatch
	{
		private static void Postfix(Player __instance)
		{
			WardMinimapPinsManager.UpdatePendingRemoteState(__instance);
		}
	}
	internal static class WardMinimapSnapshotProtocol
	{
		internal const int MaxEntryCount = 16384;

		internal static bool IsValidEntry(WardMinimapSnapshotEntry entry)
		{
			//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_0013: 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_0039: Unknown result type (might be due to invalid IL or missing references)
			ZDOID zdoId = entry.ZdoId;
			if (!((ZDOID)(ref zdoId)).IsNone() && IsFinite(entry.Position.x) && IsFinite(entry.Position.y) && IsFinite(entry.Position.z) && IsFinite(entry.Radius) && entry.Radius >= 8f)
			{
				return entry.Radius <= 64f;
			}
			return false;
		}

		private static bool IsFinite(float value)
		{
			if (!float.IsNaN(value))
			{
				return !float.IsInfinity(value);
			}
			return false;
		}
	}
	internal readonly struct WardMinimapSnapshotEntry
	{
		internal ZDOID ZdoId { get; }

		internal Vector3 Position { get; }

		internal float Radius { get; }

		internal bool IsEnabled { get; }

		internal WardMinimapSnapshotEntry(ZDOID zdoId, Vector3 position, float radius, bool isEnabled)
		{
			//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)
			ZdoId = zdoId;
			Position = position;
			Radius = radius;
			IsEnabled = isEnabled;
		}
	}
	internal readonly struct WardMinimapViewerSnapshot
	{
		private static readonly IReadOnlyDictionary<ZDOID, uint> EmptyVisibleWardDataRevisions = new Dictionary<ZDOID, uint>(0);

		internal static WardMinimapViewerSnapshot Empty { get; } = new WardMinimapViewerSnapshot(0, 0, 0, 0, 0, Array.Empty<WardMinimapSnapshotEntry>(), EmptyVisibleWardDataRevisions);

		internal int ViewerRevisionToken { get; }

		internal int IndexedWardCount { get; }

		internal int CandidateWardCount { get; }

		internal int VisibleWardCount { get; }

		internal int EnabledWardCount { get; }

		internal IReadOnlyList<WardMinimapSnapshotEntry> Entries { get; }

		internal IReadOnlyDictionary<ZDOID, uint> VisibleWardDataRevisions { get; }

		internal WardMinimapViewerSnapshot(int viewerRevisionToken, int indexedWardCount, int candidateWardCount, int visibleWardCount, int enabledWardCount, IReadOnlyList<WardMinimapSnapshotEntry>? entries, IReadOnlyDictionary<ZDOID, uint>? visibleWardDataRevisions)
		{
			ViewerRevisionToken = viewerRevisionToken;
			IndexedWardCount = indexedWardCount;
			CandidateWardCount = candidateWardCount;
			VisibleWardCount = visibleWardCount;
			EnabledWardCount = enabledWardCount;
			Entries = entries ?? Array.Empty<WardMinimapSnapshotEntry>();
			VisibleWardDataRevisions = visibleWardDataRevisions ?? EmptyVisibleWardDataRevisions;
		}
	}
	internal static class WardMinimapViewerSnapshotBuilder
	{
		internal static WardMinimapViewerSnapshot Build(long playerId, int playerGuildId, bool canSeeAllWards, int viewerRevisionToken, bool includeEntries, bool includeVisibleWardDataRevisions)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: 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)
			ZDOID[] visibleCandidateWardIds = WardMinimapVisibilityIndex.GetVisibleCandidateWardIds(playerId, playerGuildId, canSeeAllWards);
			int indexedWardCount = WardMinimapVisibilityIndex.GetIndexedWardCount();
			int candidateWardCount = visibleCandidateWardIds.Length;
			int num = 0;
			int num2 = 0;
			List<WardMinimapSnapshotEntry> list = ((includeEntries && visibleCandidateWardIds.Length != 0) ? new List<WardMinimapSnapshotEntry>(visibleCandidateWardIds.Length) : null);
			Dictionary<ZDOID, uint> dictionary = ((includeVisibleWardDataRevisions && visibleCandidateWardIds.Length != 0) ? new Dictionary<ZDOID, uint>(visibleCandidateWardIds.Length) : null);
			for (int i = 0; i < visibleCandidateWardIds.Length; i++)
			{
				if (!WardMinimapVisibilityIndex.TryGetEntry(visibleCandidateWardIds[i], out var entry))
				{
					continue;
				}
				WardMinimapSnapshotEntry wardMinimapSnapshotEntry = new WardMinimapSnapshotEntry(entry.ZdoId, entry.Position, entry.Radius, entry.IsEnabled);
				if (WardMinimapSnapshotProtocol.IsValidEntry(wardMinimapSnapshotEntry))
				{
					num++;
					if (wardMinimapSnapshotEntry.IsEnabled)
					{
						num2++;
					}
					list?.Add(wardMinimapSnapshotEntry);
					if (dictionary != null)
					{
						dictionary[wardMinimapSnapshotEntry.ZdoId] = (WardMinimapVisibilityIndex.TryGetDataRevision(wardMinimapSnapshotEntry.ZdoId, out var dataRevision) ? dataRevision : 0u);
					}
				}
			}
			int visibleWardCount = num;
			int enabledWardCount = num2;
			IReadOnlyList<WardMinimapSnapshotEntry> entries;
			if (list != null && list.Count != 0)
			{
				IReadOnlyList<WardMinimapSnapshotEntry> readOnlyList = list;
				entries = readOnlyList;
			}
			else
			{
				IReadOnlyList<WardMinimapSnapshotEntry> readOnlyList = Array.Empty<WardMinimapSnapshotEntry>();
				entries = readOnlyList;
			}
			return new WardMinimapViewerSnapshot(viewerRevisionToken, indexedWardCount, candidateWardCount, visibleWardCount, enabledWardCount, entries, dictionary);
		}
	}
	internal readonly struct WardMinimapVisibilityIndexedEntry
	{
		internal ZDOID ZdoId { get; }

		internal long OwnerPlayerId { get; }

		internal int WardGuildId { get; }

		internal Vector3 Position { get; }

		internal float Radius { get; }

		internal bool IsEnabled { get; }

		internal IReadOnlyList<long> PermittedPlayerIds { get; }

		internal WardMinimapVisibilityIndexedEntry(ZDOID zdoId, long ownerPlayerId, int wardGuildId, Vector3 position, float radius, bool isEnabled, IReadOnlyList<long> permittedPlayerIds)
		{
			//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_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)
			ZdoId = zdoId;
			OwnerPlayerId = ownerPlayerId;
			WardGuildId = wardGuildId;
			Position = position;
			Radius = radius;
			IsEnabled = isEnabled;
			PermittedPlayerIds = permittedPlayerIds ?? Array.Empty<long>();
		}
	}
	internal static class WardMinimapVisibilityIndex
	{
		private sealed class ViewerCacheState
		{
			internal int GuildId;

			internal bool CanSeeAllWards;

			internal int IndexedRevision;

			internal int ViewerRevisionToken;

			internal ZDOID[] VisibleWardIds = Array.Empty<ZDOID>();
		}

		private static readonly Dictionary<ZDOID, WardMinimapVisibilityIndexedEntry> IndexedWards = new Dictionary<ZDOID, WardMinimapVisibilityIndexedEntry>();

		private static readonly Dictionary<long, ViewerCacheState> ViewerCaches = new Dictionary<long, ViewerCacheState>();

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

		private static readonly Dictionary<ZDOID, uint> IndexedWardDataRevisions = new Dictionary<ZDOID, uint>();

		private static bool _prepared;

		private static int _indexRevision;

		private static int _nextViewerRevisionToken;

		internal static void ResetRuntimeState()
		{
			IndexedWards.Clear();
			IndexedWardDataRevisions.Clear();
			ViewerCaches.Clear();
			PrepareBuffer.Clear();
			_prepared = false;
			_indexRevision = 0;
			_nextViewerRevisionToken = 0;
		}

		internal static bool TryPrepare(ZDOMan? zdoMan)
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			if (_prepared)
			{
				return true;
			}
			if (zdoMan == null)
			{
				return false;
			}
			PrepareBuffer.Clear();
			int num = 0;
			while (!zdoMan.GetAllZDOsWithPrefabIterative("piece_stuward", PrepareBuffer, ref num))
			{
			}
			IndexedWards.Clear();
			IndexedWardDataRevisions.Clear();
			for (int i = 0; i < PrepareBuffer.Count; i++)
			{
				ZDO val = PrepareBuffer[i];
				if (TryBuildEntry(val, out var entry))
				{
					IndexedWards[entry.ZdoId] = entry;
					IndexedWardDataRevisions[entry.ZdoId] = val.DataRevision;
				}
			}
			_prepared = true;
			BumpIndexRevision();
			return true;
		}

		internal static bool NotifyWardStateChanged(PrivateArea? area)
		{
			if ((Object)(object)area == (Object)null)
			{
				return false;
			}
			return UpdateEntry(area);
		}

		internal static bool NotifyWardStateChanged(ZDO? zdo)
		{
			return UpdateEntry(zdo);
		}

		internal static bool ForgetWard(ZDOID zdoId)
		{
			//IL_0005: 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)
			IndexedWardDataRevisions.Remove(zdoId);
			if (!IndexedWards.Remove(zdoId))
			{
				return false;
			}
			BumpIndexRevision();
			return true;
		}

		internal static void InvalidateAll()
		{
			IndexedWards.Clear();
			IndexedWardDataRevisions.Clear();
			ViewerCaches.Clear();
			PrepareBuffer.Clear();
			_prepared = false;
			BumpIndexRevision();
		}

		internal static int GetViewerRevisionToken(long playerId, int guildId, bool canSeeAllWards)
		{
			return GetOrBuildViewerCache(playerId, guildId, canSeeAllWards).ViewerRevisionToken;
		}

		internal static ZDOID[] GetVisibleCandidateWardIds(long playerId, int guildId, bool canSeeAllWards)
		{
			return GetOrBuildViewerCache(playerId, guildId, canSeeAllWards).VisibleWardIds;
		}

		internal static bool TryGetEntry(ZDOID zdoId, out WardMinimapVisibilityIndexedEntry entry)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return IndexedWards.TryGetValue(zdoId, out entry);
		}

		internal static bool TryGetDataRevision(ZDOID zdoId, out uint dataRevision)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return IndexedWardDataRevisions.TryGetValue(zdoId, out dataRevision);
		}

		internal static int GetIndexedWardCount()
		{
			return IndexedWards.Count;
		}

		internal static void PruneViewerCaches(HashSet<long> activePlayerIds)
		{
			if (ViewerCaches.Count == 0)
			{
				return;
			}
			if (activePlayerIds.Count == 0)
			{
				ViewerCaches.Clear();
				return;
			}
			List<long> list = null;
			foreach (KeyValuePair<long, ViewerCacheState> viewerCache in ViewerCaches)
			{
				if (!activePlayerIds.Contains(viewerCache.Key))
				{
					if (list == null)
					{
						list = new List<long>();
					}
					list.Add(viewerCache.Key);
				}
			}
			if (list != null)
			{
				for (int i = 0; i < list.Count; i++)
				{
					ViewerCaches.Remove(list[i]);
				}
			}
		}

		private static ViewerCacheState GetOrBuildViewerCache(long playerId, int guildId, bool canSeeAllWards)
		{
			if (!ViewerCaches.TryGetValue(playerId, out ViewerCacheState value))
			{
				value = new ViewerCacheState();
				ViewerCaches[playerId] = value;
			}
			if (value.ViewerRevisionToken != 0 && value.GuildId == guildId && value.CanSeeAllWards == canSeeAllWards && value.IndexedRevision == _indexRevision)
			{
				return value;
			}
			value.VisibleWardIds = BuildVisibleWardIds(playerId, guildId, canSeeAllWards);
			value.GuildId = guildId;
			value.CanSeeAllWards = canSeeAllWards;
			value.IndexedRevision = _indexRevision;
			value.ViewerRevisionToken = NextViewerRevisionToken();
			return value;
		}

		private static ZDOID[] BuildVisibleWardIds(long playerId, int guildId, bool canSeeAllWards)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			if (IndexedWards.Count == 0)
			{
				return Array.Empty<ZDOID>();
			}
			List<ZDOID> list = new List<ZDOID>(IndexedWards.Count);
			WardGuildIdentity playerGuild = new WardGuildIdentity(guildId, string.Empty);
			foreach (WardMinimapVisibilityIndexedEntry value in IndexedWards.Values)
			{
				if (canSeeAllWards || ManagedWardAccessEvaluator.HasPlayerAccessToManagedWardIndexEntry(value, playerId, playerGuild))
				{
					list.Add(value.ZdoId);
				}
			}
			if (list.Count != 0)
			{
				return list.ToArray();
			}
			return Array.Empty<ZDOID>();
		}

		private static bool UpdateEntry(ZDO? zdo)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (!TryBuildEntry(zdo, out var entry))
			{
				if (zdo != null)
				{
					return ForgetWard(zdo.m_uid);
				}
				return false;
			}
			return ApplyEntry(entry, zdo.DataRevision);
		}

		private static bool UpdateEntry(PrivateArea? area)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (!TryBuildEntry(area, out var entry))
			{
				ZDO zdo = WardPrivateAreaSafeAccess.GetZdo(area);
				if (zdo != null)
				{
					return ForgetWard(zdo.m_uid);
				}
				return false;
			}
			ZDO zdo2 = WardPrivateAreaSafeAccess.GetZdo(area);
			return ApplyEntry(entry, (zdo2 != null) ? zdo2.DataRevision : 0u);
		}

		private static bool ApplyEntry(WardMinimapVisibilityIndexedEntry entry, uint dataRevision)
		{
			//IL_0007: 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_005d: 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_0049: Unknown result type (might be due to invalid IL or missing references)
			uint value;
			bool flag = IndexedWardDataRevisions.TryGetValue(entry.ZdoId, out value);
			if (flag && value > dataRevision)
			{
				return false;
			}
			if (IndexedWards.TryGetValue(entry.ZdoId, out var value2) && EntriesEqual(value2, entry))
			{
				if (!flag || value != dataRevision)
				{
					IndexedWardDataRevisions[entry.ZdoId] = dataRevision;
				}
				return false;
			}
			IndexedWards[entry.ZdoId] = entry;
			IndexedWardDataRevisions[entry.ZdoId] = dataRevision;
			BumpIndexRevision();
			return true;
		}

		private static bool TryBuildEntry(ZDO? zdo, out WardMinimapVisibilityIndexedEntry entry)
		{
			//IL_0015: 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 (!WardOwnership.IsManagedWardZdo(zdo))
			{
				entry = default(WardMinimapVisibilityIndexedEntry);
				return false;
			}
			entry = new WardMinimapVisibilityIndexedEntry(zdo.m_uid, zdo.GetLong(ZDOVars.s_creator, 0L), GuildsCompat.ResolveWardGuildIdentityReadOnly(zdo).Id, zdo.GetPosition(), WardSettings.GetStoredRadius(zdo), zdo.GetBool(ZDOVars.s_enabled, false), WardPrivateAreaSafeAccess.GetPermittedPlayerIds(zdo));
			return true;
		}

		private static bool TryBuildEntry(PrivateArea? area, out WardMinimapVisibilityIndexedEntry entry)
		{
			//IL_0026: 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)
			ZDO zdo = WardPrivateAreaSafeAccess.GetZdo(area);
			if ((Object)(object)area == (Object)null || zdo == null || !WardOwnership.IsManagedWardZdo(zdo))
			{
				entry = default(WardMinimapVisibilityIndexedEntry);
				return false;
			}
			entry = new WardMinimapVisibilityIndexedEntry(zdo.m_uid, zdo.GetLong(ZDOVars.s_creator, 0L), GuildsCompat.ResolveWardGuildIdentityReadOnly(zdo).Id, ((Component)area).transform.position, WardSettings.GetStoredRadiusOrMin(area), area.IsEnabled(), WardPrivateAreaSafeAccess.GetPermittedPlayerIds(zdo));
			return true;
		}

		private static bool EntriesEqual(WardMinimapVisibilityIndexedEntry left, WardMinimapVisibilityIndexedEntry right)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (left.OwnerPlayerId != right.OwnerPlayerId || left.WardGuildId != right.WardGuildId || left.Position != right.Position || !Mathf.Approximately(left.Radius, right.Radius) || left.IsEnabled != right.IsEnabled || left.PermittedPlayerIds.Count != right.PermittedPlayerIds.Count)
			{
				return false;
			}
			for (int i = 0; i < left.PermittedPlayerIds.Count; i++)
			{
				if (left.PermittedPlayerIds[i] != right.PermittedPlayerIds[i])
				{
					return false;
				}
			}
			return true;
		}

		private static void BumpIndexRevision()
		{
			if (_indexRevision == int.MaxValue)
			{
				_indexRevision = 1;
				ViewerCaches.Clear();
			}
			else
			{
				_indexRevision++;
			}
		}

		private static int NextViewerRevisionToken()
		{
			if (_nextViewerRevisionToken == int.MaxValue)
			{
				_nextViewerRevisionToken = 1;
				return _nextViewerRevisionToken;
			}
			_nextViewerRevisionToken++;
			return _nextViewerRevisionToken;
		}
	}
	internal static class WardMapRangeSprites
	{
		private const int TextureSize = 512;

		private const int FixedDashCount = 24;

		private const int FixedStrokePixels = 12;

		private const float DashFillFraction = 0.55f;

		private const float RadialFeatherPixels = 1.25f;

		private static Sprite? _cachedSprite;

		private static Texture2D? _createdTexture;

		internal static void Reset()
		{
			if ((Object)(object)_cachedSprite != (Object)null)
			{
				Object.Destroy((Object)(object)_cachedSprite);
				_cachedSprite = null;
			}
			if ((Object)(object)_createdTexture != (Object)null)
			{
				Object.Destroy((Object)(object)_createdTexture);
				_createdTexture = null;
			}
		}

		internal static Sprite? GetRangeSprite()
		{
			if ((Object)(object)_cachedSprite != (Object)null)
			{
				return _cachedSprite;
			}
			try
			{
				_cachedSprite = CreateSprite();
				return _cachedSprite;
			}
			catch (Exception)
			{
				return null;
			}
		}

		private static Sprite CreateSprite()
		{
			//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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: 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)
			int num = 24;
			int num2 = 12;
			Texture2D val = new Texture2D(512, 512, (TextureFormat)5, false)
			{
				name = $"STUWard_RangeRing_Dashed_{num}_{num2}",
				wrapMode = (TextureWrapMode)1,
				filterMode = (FilterMode)1,
				hideFlags = (HideFlags)61
			};
			Color32[] array = (Color32[])(object)new Color32[262144];
			float num3 = 255.5f;
			float num4 = num3 - 2f;
			float innerRadius = Mathf.Max(0f, num4 - (float)num2);
			float num5 = Mathf.Max(1f, (float)Math.PI * 2f * num4);
			float dashFeatherFraction = Mathf.Clamp((float)num / num5, 0.0025f, 0.08f);
			for (int i = 0; i < 512; i++)
			{
				float num6 = (float)i - num3;
				for (int j = 0; j < 512; j++)
				{
					float num7 = (float)j - num3;
					float radialAlpha = GetRadialAlpha(Mathf.Sqrt(num7 * num7 + num6 * num6), innerRadius, num4);
					if (!(radialAlpha <= 0f))
					{
						float dashAlpha = GetDashAlpha(Mathf.Atan2(num6, num7), num, dashFeatherFraction);
						if (!(dashAlpha <= 0f))
						{
							float num8 = Mathf.Clamp01(radialAlpha * dashAlpha);
							array[i * 512 + j] = new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, (byte)Mathf.RoundToInt(num8 * 255f));
						}
					}
				}
			}
			val.SetPixels32(array);
			val.Apply(false, true);
			_createdTexture = val;
			Sprite obj = Sprite.Create(val, new Rect(0f, 0f, 512f, 512f), new Vector2(0.5f, 0.5f), 100f, 0u, (SpriteMeshType)0);
			((Object)obj).name = ((Object)val).name;
			((Object)obj).hideFlags = (HideFlags)61;
			return obj;
		}

		private static float GetRadialAlpha(float distance, float innerRadius, float outerRadius)
		{
			if (distance <= innerRadius - 1.25f || distance >= outerRadius + 1.25f)
			{
				return 0f;
			}
			if (distance < innerRadius + 1.25f)
			{
				return Mathf.Clamp01((distance - (innerRadius - 1.25f)) / 2.5f);
			}
			if (distance > outerRadius - 1.25f)
			{
				return Mathf.Clamp01((outerRadius + 1.25f - distance) / 2.5f);
			}
			return 1f;
		}

		private static float GetDashAlpha(float angle, int dashCount, float dashFeatherFraction)
		{
			if (dashCount <= 0)
			{
				return 1f;
			}
			float num = Mathf.Repeat(angle / ((float)Math.PI * 2f), 1f) * (float)dashCount;
			float num2 = num - Mathf.Floor(num);
			if (num2 >= 0.55f)
			{
				return 0f;
			}
			if (dashFeatherFraction <= 0f)
			{
				return 1f;
			}
			float num3 = Mathf.Clamp01(num2 / dashFeatherFraction);
			float num4 = Mathf.Clamp01((0.55f - num2) / dashFeatherFraction);
			return Mathf.Min(num3, num4);
		}
	}
	internal static class WardInteractionPatchTargets
	{
		private static readonly Type[] CommonTargetTypes = new Type[16]
		{
			typeof(Container),
			typeof(Door),
			typeof(ShipControlls),
			typeof(Vagon),
			typeof(Sign),
			typeof(ItemStand),
			typeof(Beehive),
			typeof(CraftingStation),
			typeof(Fermenter),
			typeof(SapCollector),
			typeof(Trap),
			typeof(Tameable),
			typeof(Sadle),
			typeof(TeleportWorld),
			typeof(Feast),
			typeof(Pickable)
		};

		internal static IEnumerable<MethodBase> GetCommonTargets(string methodName)
		{
			for (int index = 0; index < CommonTargetTypes.Length; index++)
			{
				yield return RequireDeclaredMethod(CommonTargetTypes[index], methodName);
			}
		}

		internal static IEnumerable<MethodBase> GetDirectInteractTargets()
		{
			foreach (MethodBase commonTarget in GetCommonTargets("Interact"))
			{
				yield return commonTarget;
			}
			yield return RequireDeclaredMethod(typeof(ItemDrop), "Interact");
		}

		internal static bool TryGetRestriction(Component? target, out WardRestrictionOptions restriction)
		{
			WardRestrictionOptions wardRestrictionOptions = ((target is Door) ? WardRestrictionOptions.Doors : ((target is TeleportWorld) ? WardRestrictionOptions.Portals : ((target is Feast) ? WardRestrictionOptions.PlacedConsumables : ((target is ItemStand) ? WardRestrictionOptions.ItemStands : ((target is ArmorStand) ? WardRestrictionOptions.ArmorStands : ((target is Container) ? WardRestrictionOptions.Containers : ((target is CraftingStation) ? WardRestrictionOptions.CraftingStations : ((target is Tameable) ? WardRestrictionOptions.TameablesAndSaddles : ((target is Sadle) ? WardRestrictionOptions.TameablesAndSaddles : WardRestrictionOptions.None)))))))));
			restriction = wardRestrictionOptions;
			return restriction != WardRestrictionOptions.None;
		}

		private static MethodBase RequireDeclaredMethod(Type type, string methodName)
		{
			MethodInfo methodInfo = AccessTools.DeclaredMethod(type, methodName, (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				throw new MissingMethodException(type.FullName, methodName);
			}
			return methodInfo;
		}
	}
	internal struct WardCheckScopeState
	{
		private WardAccess.RestrictionScope _restrictionScope;

		private WardAccess.ManagedWardAllowScope _allowScope;

		private bool _disposed;

		internal void EnterRestriction(WardRestrictionOptions restriction)
		{
			_restrictionScope = WardAccess.EnterRestrictionScope(restriction);
		}

		internal void EnterManagedWardAllow()
		{
			_allowScope = WardAccess.EnterManagedWardAllowScope();
		}

		internal void Dispose()
		{
			if (!_disposed)
			{
				_disposed = true;
				_restrictionScope.Dispose();
				_allowScope.Dispose();
			}
		}
	}
	[HarmonyPatch]
	internal static class DirectInteractionPatches
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			return WardInteractionPatchTargets.GetDirectInteractTargets();
		}

		private static bool Prefix(Component __instance, Humanoid __0, ref bool __result, out WardCheckScopeState __state)
		{
			__state = default(WardCheckScopeState);
			Player player = WardAccess.GetPlayer(__0);
			return TryHandleDirectInteraction(__instance, player, ref __result, ref __state);
		}

		private static Exception? Finalizer(ref WardCheckScopeState __state, Exception? __exception)
		{
			__state.Dispose();
			return __exception;
		}

		private static bool TryHandleDirectInteraction(Component target, Player? player, ref bool result, ref WardCheckScopeState scopeState)
		{
			ItemDrop val = (ItemDrop)(object)((target is ItemDrop) ? target : null);
			if (val != null)
			{
				if (WardAccess.IsPlacedConsumable(val))
				{
					return TryBlockWithRestriction(WardRestrictionOptions.PlacedConsumables, (Component)(object)val, player, ref result, ref scopeState);
				}
				if (!WardItemPrefabPolicy.CanAnyPickupBeBlocked() || !WardItemPrefabPolicy.ShouldBlockPickup(val))
				{
					scopeState.EnterManagedWardAllow();
					return true;
				}
				if (!WardAccess.ShouldBlockPickup(val, player))
				{
					scopeState.EnterRestriction(WardRestrictionOptions.Pickup);
					return true;
				}
				WardAccess.ShowNoAccessMessage(player);
				result = true;
				return false;
			}
			if (WardInteractionPatchTargets.TryGetRestriction(target, out var restriction))
			{
				return TryBlockWithRestriction(restriction, target, player, ref result, ref scopeState);
			}
			return WardAccess.TryBlockInteraction(target, player, ref result);
		}

		private static bool TryBlockWithRestriction(WardRestrictionOptions restriction, Component target, Player? player, ref bool result, ref WardCheckScopeState scopeState)
		{
			bool num = WardAccess.TryBlockInteraction(restriction, target, player, ref result);
			if (num)
			{
				scopeState.EnterRestriction(restriction);
			}
			return num;
		}
	}
	[HarmonyPatch(typeof(PrivateArea), "HaveLocalAccess")]
	internal static class PrivateAreaHaveLocalAccessManagedPatch
	{
		private static void Postfix(PrivateArea __instance, ref bool __result)
		{
			if (!__result && WardAccess.IsManagedWard(__instance, requireEnabled: false))
			{
				Player localPlayer = Player.m_localPlayer;
				if (!((Object)(object)localPlayer == (Object)null))
				{
					__result = WardAccess.HasManagedWardTrust(__instance, localPlayer.GetPlayerID());
				}
			}
		}
	}
	[HarmonyPatch(typeof(PrivateArea), "CheckAccess")]
	internal static class PrivateAreaCheckAccessManagedPatch
	{
		private static bool Prefix(Vector3 point, float radius, bool flash, bool wardCheck, ref bool __result)
		{
			//IL_0063: 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_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_00a3: 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)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || !WardAccess.HasEnabledManagedWards())
			{
				return true;
			}
			float radius2 = radius;
			GameObject placementGhost = localPlayer.m_placementGhost;
			PrivateArea area = (((Object)(object)placementGhost != (Object)null) ? placementGhost.GetComponent<PrivateArea>() : null);
			if ((Object)(object)placementGhost != (Object)null && StuWardArea.IsManaged(area) && Vector3.Distance(placementGhost.transform.position, point) <= 0.1f)
			{
				radius2 = 8f;
			}
			IReadOnlyList<PrivateArea> candidateManagedWards = WardAccess.GetCandidateManagedWards(point, radius2, requireEnabled: true);
			if (WardAccess.IsManagedWardAllowScopeActive && WardAccess.IsInsideAnyManagedWard(point, radius2, candidateManagedWards))
			{
				__result = true;
				return false;
			}
			WardRestrictionOptions restriction;
			WardAccess.AccessResult accessResult = (WardAccess.TryGetRestrictionScope(out restriction) ? WardAccess.EvaluateRestrictionAccessAgainstCandidates(restriction, point, radius2, localPlayer.GetPlayerID(), candidateManagedWards, flash, wardCheck) : WardAccess.EvaluateAccessAgainstCandidates(point, radius2, localPlayer.GetPlayerID(), candidateManagedWards, flash, wardCheck));
			if (accessResult.Decision == WardAccess.AccessDecision.NoWard)
			{
				return true;
			}
			__result = !accessResult.IsDenied;
			return false;
		}
	}
	[HarmonyPatch(typeof(Container), "CheckAccess")]
	internal static class ContainerCheckAccessManagedPatch
	{
		private static bool Prefix(Container __instance, long playerID, ref bool __result)
		{
			//IL_001b: 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 ((Object)(object)__instance == (Object)null || playerID == 0L || !WardAccess.HasEnabledManagedWards())
			{
				return true;
			}
			IReadOnlyList<PrivateArea> candidateManagedWards = WardAccess.GetCandidateManagedWards(((Component)__instance).transform.position, 0f, requireEnabled: true);
			WardAccess.AccessResult accessResult = WardAccess.EvaluateRestrictionAccessAgainstCandidates(WardRestrictionOptions.Containers, ((Component)__instance).transform.position, 0f, playerID, candidateManagedWards, flash: false);
			if (accessResult.Decision == WardAccess.AccessDecision.NoWard)
			{
				return true;
			}
			__result = !accessResult.IsDenied;
			return false;
		}
	}
	[HarmonyPatch]
	[HarmonyPriority(800)]
	[HarmonyBefore(new string[] { "sighsorry.FeedLikeGrandma" })]
	internal static class UseItemInteractionPatches
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			return WardInteractionPatchTargets.GetCommonTargets("UseItem");
		}

		private static bool Prefix(Component __instance, Humanoid __0, ItemData __1, ref bool __result, out WardCheckScopeState __state)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			__state = default(WardCheckScopeState);
			Player player = WardAccess.GetPlayer(__0);
			if (!WardAccess.TryBlockItemUse(player, __1, __instance.transform.position))
			{
				__result = false;
				return false;
			}
			WardRestrictionOptions restriction;
			bool num = (WardInteractionPatchTargets.TryGetRestriction(__instance, out restriction) ? WardAccess.TryBlockInteraction(restriction, __instance, player, ref __result) : WardAccess.TryBlockInteraction(__instance, player, ref __result));
			if (num && restriction != WardRestrictionOptions.None)
			{
				__state.EnterRestriction(restriction);
			}
			return num;
		}

		private static Exception? Finalizer(ref WardCheckScopeState __state, Exception? __exception)
		{
			__state.Dispose();
			return __exception;
		}
	}
	[HarmonyPatch]
	internal static class StationUsePatches
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			yield return AccessTools.DeclaredMethod(typeof(ArmorStand), "UseItem", (Type[])null, (Type[])null);
			yield return AccessTools.DeclaredMethod(typeof(MapTable), "OnRead", new Type[3]
			{
				typeof(Switch),
				typeof(Humanoid),
				typeof(ItemData)
			}, (Type[])null);
			yield return AccessTools.DeclaredMethod(typeof(MapTable), "OnRead", new Type[4]
			{
				typeof(Switch),
				typeof(Humanoid),
				typeof(ItemData),
				typeof(bool)
			}, (Type[])null);
			yield return AccessTools.DeclaredMethod(typeof(MapTable), "OnWrite", (Type[])null, (Type[])null);
		}

		private static bool Prefix(Component __instance, Humanoid __1, ref bool __result, out WardCheckScopeState __state)
		{
			__state = default(WardCheckScopeState);
			Player player = WardAccess.GetPlayer(__1);
			WardRestrictionOptions restriction;
			bool num = (WardInteractionPatchTargets.TryGetRestriction(__instance, out restriction) ? WardAccess.TryBlockInteraction(restriction, __instance, player, ref __result) : WardAccess.TryBlockInteraction(__instance, player, ref __result));
			if (num && restriction != WardRestrictionOptions.None)
			{
				__state.EnterRestriction(restriction);
			}
			return num;
		}

		private static Exception? Finalizer(ref WardCheckScopeState __state, Exception? __exception)
		{
			__state.Dispose();
			return __exception;
		}
	}
	[HarmonyPatch]
	internal static class ProcessingInteractionPatches
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			yield return AccessTools.DeclaredMethod(typeof(Smelter), "OnAddOre", (Type[])null, (Type[])null);
			yield return AccessTools.DeclaredMethod(typeof(Smelter), "OnAddFuel", (Type[])null, (Type[])null);
			yield return AccessTools.DeclaredMethod(typeof(Incinerator), "OnIncinerate", (Type[])null, (Type[])null);
		}

		private static bool Prefix(Component __instance, Humanoid __1, ref bool __result)
		{
			return WardAccess.TryBlockAction(__instance, WardAccess.GetPlayer(__1), ref __result);
		}
	}
	[HarmonyPatch(typeof(TeleportWorld), "Teleport")]
	internal static class TeleportWorldTeleportPatch
	{
		private static bool Prefix(TeleportWorld __instance, Player player, out WardCheckScopeState __state)
		{
			__state = default(WardCheckScopeState);
			bool num = WardAccess.TryBlockVoid(WardRestrictionOptions.Portals, (Component)(object)__instance, player);
			if (num)
			{
				__state.EnterRestriction(WardRestrictionOptions.Portals);
			}
			return num;
		}

		private static Exception? Finalizer(ref WardCheckScopeState __state, Exception? __exception)
		{
			__state.Dispose();
			return __exception;
		}
	}
	[HarmonyPatch(typeof(TeleportWorldTrigger), "OnTriggerEnter")]
	[HarmonyPriority(800)]
	[HarmonyBefore(new string[] { "org.bepinex.plugins.targetportal" })]
	internal static class TeleportWorldTriggerPatch
	{
		private static bool Prefix(TeleportWorldTrigger __instance, Collider colliderIn, out WardCheckScopeState __state)
		{
			__state = default(WardCheckScopeState);
			Player player = WardAccess.GetPlayer(colliderIn);
			if ((Object)(object)player == (Object)null)
			{
				return true;
			}
			TeleportWorld componentInParent = ((Component)__instance).GetComponentInParent<TeleportWorld>();
			if ((Object)(object)componentInParent == (Object)null)
			{
				TargetPortalCompat.ClearBlockedPortalEntry(player);
				return true;
			}
			if (WardAccess.TryBlockVoid(WardRestrictionOptions.Portals, (Component)(object)componentInParent, player))
			{
				__state.EnterRestriction(WardRestrictionOptions.Portals);
				TargetPortalCompat.ClearBlockedPortalEntry(player);
				return true;
			}
			TargetPortalCompat.MarkBlockedPortalEntry(player);
			TargetPortalCompat.ClosePortalSelection();
			return false;
		}

		private static Exception? Finalizer(ref WardCheckScopeState __state, Exception? __exception)
		{
			__state.Dispose();
			return __exception;
		}
	}
	internal static class TargetPortalCompat
	{
		private const string PluginGuid = "org.bepinex.plugins.targetportal";

		private static readonly Assembly? TargetPortalAssembly = GetPluginAssembly();

		private static readonly Type? MapType = TargetPortalAssembly?.GetType("TargetPortal.Map");

		private static readonly Type? OpenMapPatchType = TargetPortalAssembly?.GetType("TargetPortal.Map+OpenMapOnPortalEnter");

		private static readonly Type? TogglePortalModePatchType = TargetPortalAssembly?.GetType("TargetPortal.TargetPortal+TogglePortalMode");

		private static readonly Type? StartPortalFetchingPatchType = TargetPortalAssembly?.GetType("TargetPortal.TargetPortal+StartPortalFetching");

		private static readonly MethodInfo? OpenMapPrefixMethod = ((OpenMapPatchType != null) ? AccessTools.Method(OpenMapPatchType, "Prefix", new Type[2]
		{
			typeof(TeleportWorldTrigger),
			typeof(Collider)
		}, (Type[])null) : null);

		private static readonly MethodInfo? TogglePortalModePrefixMethod = ((TogglePortalModePatchType != null) ? AccessTools.Method(TogglePortalModePatchType, "Prefix", new Type[2]
		{
			typeof(TeleportWorld),
			typeof(bool)
		}, (Type[])null) : null);

		private static readonly MethodInfo? OnPortalModeChangeMethod = ((StartPortalFetchingPatchType != null) ? AccessTools.Method(StartPortalFetchingPatchType, "OnPortalModeChange", new Type[5]
		{
			typeof(long),
			typeof(ZDOID),
			typeof(int),
			typeof(string),
			typeof(string)
		}, (Type[])null) : null);

		private static readonly MethodInfo? HandlePortalClickMethod = ((MapType != null) ? AccessTools.Method(MapType, "HandlePortalClick", (Type[])null, (Type[])null) : null);

		private static readonly MethodInfo? CancelTeleportMethod = ((MapType != null) ? AccessTools.Method(MapType, "CancelTeleport", Type.EmptyTypes, (Type[])null) : null);

		private static bool _blockedPortalEntry;

		private static Assembly? GetPluginAssembly()
		{
			if (!Chainloader.PluginInfos.TryGetValue("org.bepinex.plugins.targetportal", out var value))
			{
				return null;
			}
			return ((object)value.Instance)?.GetType().Assembly;
		}

		internal static void TryPatch(Harmony harmony)
		{
			if (!(TargetPortalAssembly == null) && harmony != null)
			{
				PatchMethod(harmony, OpenMapPrefixMethod, "TargetPortalOpenMapPrefix");
				PatchMethod(harmony, TogglePortalModePrefixMethod, "TargetPortalTogglePortalModePrefix");
				PatchMethod(harmony, OnPortalModeChangeMethod, "TargetPortalOnPortalModeChangePrefix");
				PatchMethod(harmony, HandlePortalClickMethod, "TargetPortalHandlePortalClickPrefix");
			}
		}

		internal static void MarkBlockedPortalEntry(Player? player)
		{
			if (!((Object)(object)player == (Object)null) && !((Object)(object)player != (Object)(object)Player.m_localPlayer))
			{
				_blockedPortalEntry = true;
			}
		}

		internal static void ClearBlockedPortalEntry(Player? player)
		{
			if (!((Object)(object)player == (Object)null) && !((Object)(object)player != (Object)(object)Player.m_localPlayer))
			{
				_blockedPortalEntry = false;
			}
		}

		internal static void ClosePortalSelection()
		{
			_blockedPortalEntry = false;
			try
			{
				if ((Object)(object)Minimap.instance != (Object)null)
				{
					Minimap.instance.SetMapMode((MapMode)1);
				}
			}
			catch
			{
			}
			try
			{
				CancelTeleportMethod?.Invoke(null, Array.Empty<object>());
			}
			catch
			{
			}
		}

		private static void PatchMethod(Harmony harmony, MethodInfo? originalMethod, string prefixName)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			if (!(originalMethod == null))
			{
				MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(TargetPortalCompat), prefixName, (Type[])null, (Type[])null);
				if (!(methodInfo == null))
				{
					harmony.Patch((MethodBase)originalMethod, new HarmonyMethod(methodInfo), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			}
		}

		private static bool TargetPortalOpenMapPrefix(TeleportWorldTrigger __0, Collider __1)
		{
			Player player = WardAccess.GetPlayer(__1);
			if ((Object)(object)player == (Object)null || (Object)(object)player != (Object)(object)Player.m_localPlayer)
			{
				return true;
			}
			TeleportWorld val = (((Object)(object)__0 != (Object)null) ? ((Component)__0).GetComponentInParent<TeleportWorld>() : null);
			if ((Object)(object)val == (Object)null)
			{
				ClearBlockedPortalEntry(player);
				return true;
			}
			if (WardAccess.TryBlockVoid(WardRestrictionOptions.Portals, (Component)(object)val, player))
			{
				ClearBlockedPortalEntry(player);
				return true;
			}
			MarkBlockedPortalEntry(player);
			ClosePortalSelection();
			return false;
		}

		private static bool TargetPortalHandlePortalClickPrefix()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				_blockedPortalEntry = false;
				return true;
			}
			if (!_blockedPortalEntry && !WardAccess.ShouldBlockRestriction(WardRestrictionOptions.Portals, ((Component)localPlayer).transform.position, 0f, localPlayer, flash: false))
			{
				return true;
			}
			WardAccess.ShowNoAccessMessage(localPlayer);
			ClosePortalSelection();
			return false;
		}

		private static bool TargetPortalTogglePortalModePrefix(TeleportWorld __0, bool __1)
		{
			if (__1)
			{
				return true;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || (Object)(object)__0 == (Object)null)
			{
				return true;
			}
			return !WardAccess.ShouldBlockRestriction(WardRestrictionOptions.Portals, (Component?)(object)__0, localPlayer, 0f, flash: false);
		}

		private static bool TargetPortalOnPortalModeChangePrefix(long __0, ZDOID __1)
		{
			//IL_0018: 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)
			if (!WardOwnership.TryResolveAuthoritativePlayerIdFromSender(__0, out var playerId))
			{
				return false;
			}
			ZDOMan instance = ZDOMan.instance;
			ZDO val = ((instance != null) ? instance.GetZDO(__1) : null);
			if (val == null)
			{
				return true;
			}
			return WardAccess.CheckRestrictionAccess(WardRestrictionOptions.Portals, val.GetPosition(), 0f, playerId, flash: false);
		}
	}
	[HarmonyPatch(typeof(ItemDrop), "Pickup")]
	internal static class ItemDropPickupPatch
	{
		private static bool Prefix(ItemDrop __instance, Humanoid character, out WardCheckScopeState __state)
		{
			__state = default(WardCheckScopeState);
			Player player = WardAccess.GetPlayer(character);
			if (!WardItemPrefabPolicy.CanAnyPickupBeBlocked() || !WardItemPrefabPolicy.ShouldBlockPickup(__instance))
			{
				__state.EnterManagedWardAllow();
				return true;
			}
			if (!WardAccess.ShouldBlockPickup(__instance, player))
			{
				__state.EnterRestriction(WardRestrictionOptions.Pickup);
				return true;
			}
			WardAccess.ShowNoAccessMessage(player);
			return false;
		}

		private static Exception? Finalizer(ref WardCheckScopeState __state, Exception? __exception)
		{
			__state.Dispose();
			return __exception;
		}
	}
	[HarmonyPatch(typeof(Humanoid), "Pickup")]
	internal static class HumanoidPickupPatch
	{
		private static bool Prefix(Humanoid __instance, GameObject go, ref bool __result, out WardCheckScopeState __state)
		{
			__state = default(WardCheckScopeState);
			Player player = WardAccess.GetPlayer(__instance);
			if (!WardItemPrefabPolicy.CanAnyPickupBeBlocked() || !WardItemPrefabPolicy.ShouldBlockPickup(go))
			{
				__state.EnterManagedWardAllow();
				return true;
			}
			if (!WardAccess.ShouldBlockPickup(go, player))
			{
				__state.EnterRestriction(WardRestrictionOptions.Pickup);
				return true;
			}
			__result = false;
			return false;
		}

		private static Exception? Finalizer(ref WardCheckScopeState __state, Exception? __exception)
		{
			__state.Dispose();
			return __exception;
		}
	}
	[HarmonyPatch(typeof(Player), "TryPlacePiece")]
	internal static class PlayerTryPlacePiecePatch
	{
		private static bool Prefix(Player __instance, ref bool __result)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			GameObject placementGhost = __instance.m_placementGhost;
			if ((Object)(object)placementGhost == (Object)null)
			{
				return true;
			}
			if (!WardAccess.TryBlockManagedWardPlacement(__instance, (Component?)(object)placementGhost.transform, placementGhost.transform.position, ref __result))
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Player), "SetupPlacementGhost")]
	internal static class PlayerSetupPlacementGhostPatch
	{
		private static void Postfix(Player __instance)
		{
			PrivateArea area = (((Object)(object)__instance.m_placementGhost != (Object)null) ? __instance.m_placementGhost.GetComponent<PrivateArea>() : null);
			if (StuWardArea.IsManaged(area))
			{
				WardSettings.ApplyPlacementGhostPreviewRadius(area);
			}
		}
	}
	[HarmonyPatch(typeof(Player), "UpdatePlacementGhost")]
	internal static class PlayerUpdatePlacementGhostPatch
	{
		private static void Postfix(Player __instance)
		{
			//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_0054: Unknown result type (might be due to invalid IL or missing references)
			GameObject placementGhost = __instance.m_placementGhost;
			PrivateArea area = (((Object)(object)placementGhost != (Object)null) ? placementGhost.GetComponent<PrivateArea>() : null);
			if ((Object)(object)placementGhost != (Object)null && StuWardArea.IsManaged(area))
			{
				WardSettings.ApplyPlacementGhostPreviewRadius(area);
				if ((int)__instance.GetPlacementStatus() == 0 && ManagedWardPlacementPreviewService.ShouldShowAsInvalid(__instance, (Component?)(object)placementGhost.transform, placementGhost.transform.position))
				{
					__instance.m_placementStatus = (PlacementStatus)5;
					__instance.SetPlacementGhostValid(false);
				}
			}
		}
	}
	[HarmonyPatch(typeof(Player), "PlacePiece")]
	internal static class PlayerPlacePiecePatch
	{
		private static bool Prefix(Player __instance, Piece piece, Vector3 pos)
		{
			//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 (!WardAccess.TryBlockManagedWardPlacement(__instance, (Component?)(object)piece, pos))
			{
				return false;
			}
			return WardAccess.TryBlockPlacement(__instance, pos, 0f);
		}
	}
	[HarmonyPatch(typeof(Player), "CheckCanRemovePiece")]
	internal static class PlayerCheckCanRemovePiecePatch
	{
		[HarmonyPriority(0)]
		private static void Postfix(Player __instance, Piece __0, ref bool __result)
		{
			if (WardPatchHelpers.ShouldBlockRemoval(__0, __instance))
			{
				WardAccess.ShowNoAccessMessage(__instance);
				__result = false;
			}
		}
	}
	[HarmonyPatch(typeof(Player), "RemovePiece")]
	internal static class PlayerRemovePiecePatch
	{
		private static bool Prefix(Player __instance, ref bool __result)
		{
			if (!WardPatchHelpers.ShouldBlockRemoval(WardPatchHelpers.FindRemoveTarget(__instance), __instance))
			{
				return true;
			}
			WardAccess.ShowNoAccessMessage(__instance);
			__result = false;
			return false;
		}
	}
	[HarmonyPatch(typeof(Player), "Repair")]
	internal static class PlayerRepairPatch
	{
		private static bool Prefix(Player __instance, Piece __1)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			Piece val = __instance.GetHoveringPiece() ?? __1;
			if ((Object)(object)val == (Object)null || !WardAccess.ShouldBlock(((Component)val).transform.position, 0f, __instance))
			{
				return true;
			}
			WardAccess.ShowNoAccessMessage(__instance);
			return false;
		}
	}
	[HarmonyPatch(typeof(ZNetScene), "Destroy", new Type[] { typeof(GameObject) })]
	internal static class ZNetSceneDestroyPatch
	{
		private static bool Prefix(GameObject go)
		{
			if (!WardPatchHelpers.ShouldBlockLocalRemoval(((Object)(object)go != (Object)null) ? (go.GetComponent<Piece>() ?? go.GetComponentInParent<Piece>()) : null))
			{
				return true;
			}
			WardAccess.ShowNoAccessMessage(Player.m_localPlayer);
			return false;
		}
	}
	[HarmonyPatch(typeof(Attack), "SpawnOnHitTerrain")]
	internal static class AttackSpawnOnHitTerrainPatch
	{
		private static bool Prefix(Vector3 hitPoint, GameObject prefab, Character character, ref GameObject __result)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			Player player = (Player)(object)((character is Player) ? character : null);
			if (!WardAccess.ShouldBlock(hitPoint, WardAccess.GetTerrainRadius(prefab), player))
			{
				return true;
			}
			WardAccess.ShowNoAccessMessage(player);
			__result = null;
			return false;
		}
	}
	[HarmonyPatch(typeof(TerrainOp), "Awake")]
	internal static class TerrainOpAwakePatch
	{
		private static bool Prefix(TerrainOp __instance)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			ZNetView component = ((Component)__instance).GetComponent<ZNetView>();
			if ((Object)(object)component != (Object)null && component.IsValid() && !component.IsOwner())
			{
				return true;
			}
			Player localPlayer = Player.m_localPlayer;
			if (!WardAccess.ShouldBlock(((Component)__instance).transform.position, __instance.GetRadius(), localPlayer))
			{
				return true;
			}
			WardAccess.ShowNoAccessMessage(localPlayer);
			Object.Destroy((Object)(object)((Component)__instance).gameObject);
			return false;
		}
	}
	[HarmonyPatch(typeof(WearNTear), "Damage")]
	internal static class WearNTearDamagePatch
	{
		private static bool Prefix(WearNTear __instance, HitData hit)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			Character attacker = hit.GetAttacker();
			Piece component = ((Component)__instance).GetComponent<Piece>();
			PrivateArea component2 = ((Component)__instance).GetComponent<PrivateArea>();
			if (ManagedWardIdentity.EnsureManagedComponent(component2))
			{
				Player localPlayerForCharacter = WardPatchHelpers.GetLocalPlayerForCharacter(attacker);
				if ((Object)(object)localPlayerForCharacter != (Object)null && !WardAccess.HasManagedWardTrust(component2, localPlayerForCharacter.GetPlayerID()))
				{
					WardAccess.ShowNoAccessMessage(localPlayerForCharacter);
				}
				return false;
			}
			BuildingDamageBlockReason buildingDamageBlockReason = WardPatchHelpers.GetBuildingDamageBlockReason(((Component)__instance).transform.position, component, attacker);
			if (buildingDamageBlockReason == BuildingDamageBlockReason.None)
			{
				return true;
			}
			Player localPlayerForCharacter2 = WardPatchHelpers.GetLocalPlayerForCharacter(attacker);
			if (buildingDamageBlockReason == BuildingDamageBlockReason.FriendlyWardProtection)
			{
				WardAccess.ShowProtectedBuildingDamageMessage(localPlayerForCharacter2);
			}
			else
			{
				WardAccess.ShowNoAccessMessage(localPlayerForCharacter2);
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(WearNTear), "RPC_Damage")]
	internal static class WearNTearRpcDamagePatch
	{
		private static bool Prefix(WearNTear __instance, long sender, HitData hit)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (ManagedWardIdentity.EnsureManagedComponent(((Component)__instance).GetComponent<PrivateArea>()))
			{
				return false;
			}
			return WardPatchHelpers.GetBuildingDamageBlockReason(((Component)__instance).transform.position, ((Component)__instance).GetComponent<Piece>(), hit, sender) == BuildingDamageBlockReason.None;
		}
	}
	[HarmonyPatch(typeof(WearNTear), "Remove")]
	internal static class WearNTearRemovePatch
	{
		private static bool Prefix(WearNTear __instance)
		{
			if (!WardPatchHelpers.ShouldBlockLocalRemoval(((Component)__instance).GetComponent<Piece>()))
			{
				return true;
			}
			WardAccess.ShowNoAccessMessage(Player.m_localPlayer);
			return false;
		}
	}
	[HarmonyPatch(typeof(WearNTear), "RPC_Remove")]
	internal static class WearNTearRpcRemovePatch
	{
		private static bool Prefix(WearNTear __instance, long sender, bool blockDrop)
		{
			Piece component = ((Component)__instance).GetComponent<Piece>();
			if (blockDrop && WardPatchHelpers.IsPlacedConsumablePiece(component))
			{
				switch (WardPatchHelpers.EvaluatePlacedConsumableRemovalBySender(component, sender))
				{
				case WardPatchHelpers.ProtectedRpcDecision.Allow:
					return true;
				case WardPatchHelpers.ProtectedRpcDecision.Deny:
					WardAccess.ShowNoAccessMessage(WardPatchHelpers.GetLocalPlayerForSender(sender));
					break;
				}
				return false;
			}
			switch (WardPatchHelpers.EvaluateRemovalBySender(component, sender))
			{
			case WardPatchHelpers.ProtectedRpcDecision.Allow:
				return true;
			case WardPatchHelpers.ProtectedRpcDecision.Deny:
				WardAccess.ShowNoAccessMessage(WardPatchHelpers.GetLocalPlayerForSender(sender));
				break;
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(Destructible), "Damage")]
	internal static class DestructibleDamagePatch
	{
		private static bool Prefix(Destructible __instance, HitData hit)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			Character attacker = hit.GetAttacker();
			BuildingDamageBlockReason buildingDamageBlockReason = WardPatchHelpers.GetBuildingDamageBlockReason(((Component)__instance).transform.position, WardPatchHelpers.GetProtectedBuildingPiece((Component?)(object)__instance), attacker);
			if (buildingDamageBlockReason == BuildingDamageBlockReason.None)
			{
				return true;
			}
			Player localPlayerForCharacter = WardPatchHelpers.GetLocalPlayerForCharacter(attacker);
			if (buildingDamageBlockReason == BuildingDamageBlockReason.FriendlyWardProtection)
			{
				WardAccess.ShowProtectedBuildingDamageMessage(localPlayerForCharacter);
			}
			else
			{
				WardAccess.ShowNoAccessMessage(localPlayerForCharacter);
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(Destructible), "RPC_Damage")]
	internal static class DestructibleRpcDamagePatch
	{
		private static bool Prefix(Destructible __instance, long sender, HitData hit)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return WardPatchHelpers.GetBuildingDamageBlockReason(((Component)__instance).transform.position, WardPatchHelpers.GetProtectedBuildingPiece((Component?)(object)__instance), hit, sender) == BuildingDamageBlockReason.None;
		}
	}
	[HarmonyPatch(typeof(TreeBase), "Damage")]
	internal static class TreeBaseDamagePatch
	{
		private static bool Prefix(TreeBase __instance, HitData hit)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return !WardPatchHelpers.ShouldBlockDamageByCharacter(((Component)__instance).transform.position, hit.GetAttacker());
		}
	}
	[HarmonyPatch(typeof(TreeBase), "RPC_Damage")]
	internal static class TreeBaseRpcDamagePatch
	{
		private static bool Prefix(TreeBase __instance, long sender)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return WardPatchHelpers.EvaluateDamageBySender(((Component)__instance).transform.position, sender) == WardPatchHelpers.ProtectedRpcDecision.Allow;
		}
	}
	[HarmonyPatch(typeof(Feast), "RPC_TryEat")]
	internal static class FeastRpcTryEatPatch
	{
		private static bool Prefix(Feast __instance, long sender)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			switch (WardPatchHelpers.EvaluateInteractionBySender(((Component)__instance).transform.position, sender, WardRestrictionOptions.PlacedConsumables))
			{
			case WardPatchHelpers.ProtectedRpcDecision.Allow:
				return true;
			case WardPatchHelpers.ProtectedRpcDecision.Deny:
				WardAccess.ShowNoAccessMessage(WardPatchHelpers.GetLocalPlayerForSender(sender));
				break;
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(Player), "UseHotbarItem")]
	[HarmonyPriority(800)]
	[HarmonyBefore(new string[] { "kg.TameableCollector", "sighsorry.FeedLikeGrandma" })]
	internal static class PlayerUseHotbarItemPatch
	{
		private static bool Prefix(Player __instance, int index)
		{
			if ((Object)(object)__instance != (Object)(object)Player.m_localPlayer || ((Humanoid)__instance).m_inventory == null)
			{
				return true;
			}
			ItemData itemAt = ((Humanoid)__instance).m_inventory.GetItemAt(index - 1, 0);
			return WardAccess.TryBlockItemUseAtPlayerOrHoveredTamedCreature(__instance, itemAt);
		}
	}
	[HarmonyPatch(typeof(Humanoid), "UseItem")]
	[HarmonyPriority(800)]
	[HarmonyBefore(new string[] { "sighsorry.FeedLikeGrandma" })]
	internal static class HumanoidUseItemPatch
	{
		private static bool Prefix(Humanoid __instance, ItemData item)
		{
			return WardAccess.TryBlockItemUseAtPlayerOrHoveredTamedCreature(WardAccess.GetPlayer(__instance), item);
		}
	}
	[HarmonyPatch(typeof(Humanoid), "UpdateEquipment")]
	internal static class HumanoidUpdateEquipmentPatch
	{
		private const float ForceUnequipCheckIntervalSeconds = 0.15f;

		private static float _nextForceUnequipCheckTime;

		private static void Prefix(Humanoid __instance)
		{
			if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer) && WardAccess.HasEnabledManagedWards() && WardItemPrefabPolicy.HasBlockedItems() && !(Time.unscaledTime < _nextForceUnequipCheckTime))
			{
				_nextForceUnequipCheckTime = Time.unscaledTime + 0.15f;
				WardAccess.TryForceUnequipBlockedItems(Player.m_localPlayer);
			}
		}
	}
	[HarmonyPatch(typeof(Humanoid), "EquipItem")]
	internal static class HumanoidEquipItemPatch
	{
		private static bool Prefix(Humanoid __instance, ItemData item, ref bool __result)
		{
			return WardAccess.TryBlockItemUse(WardAccess.GetPlayer(__instance), item, ref __result);
		}
	}
	[HarmonyPatch(typeof(Humanoid), "StartAttack")]
	internal static class HumanoidStartAttackPatch
	{
		private static bool Prefix(Humanoid __instance, ref bool __result)
		{
			return WardAccess.TryBlockAttack(WardAccess.GetPlayer(__instance), ref __result);
		}
	}
	[HarmonyPatch(typeof(Attack), "Start")]
	[HarmonyPriority(800)]
	[HarmonyBefore(new string[] { "meldurson.valheim.PortablePals" })]
	internal static class AttackStartBlockedItemTargetPatch
	{
		private static bool Prefix(Humanoid character, ItemData weapon, ref bool __result)
		{
			return WardAccess.TryBlockAttack(WardAccess.GetPlayer(character), weapon, ref __result);
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "OnRightClickItem")]
	[HarmonyPriority(800)]
	[HarmonyBefore(new string[] { "kg.TameableCollector" })]
	internal static class InventoryGuiOnRightClickItemPatch
	{
		private static bool Prefix(ItemData item)
		{
			return WardAccess.TryBlockItemUse(Player.m_localPlayer, item);
		}
	}
	[HarmonyPatch]
	internal static class TameableCollectorCollectorItemPatch
	{
		private static Type? GetCollectorItemType()
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			for (int i = 0; i < assemblies.Length; i++)
			{
				Type type = assemblies[i].GetType("TameableCollector.Mechanics+CollectorItem", throwOnError: false);
				if (type != null)
				{
					return type;
				}
			}
			return null;
		}

		private static bool Prepare()
		{
			return GetCollectorItemType() != null;
		}

		private static IEnumerable<MethodBase> TargetMethods()
		{
			Type collectorItemType = GetCollectorItemType();
			if (!(collectorItemType == null))
			{
				MethodInfo methodInfo = AccessTools.Method(collectorItemType, "TryCatch", (Type[])null, (Type[])null);
				if (methodInfo != null)
				{
					yield return methodInfo;
				}
				MethodInfo methodInfo2 = AccessTools.Method(collectorItemType, "Summon", (Type[])null, (Type[])null);
				if (methodInfo2 != null)
				{
					yield return methodInfo2;
				}
			}
		}

		[HarmonyPriority(800)]
		private static bool Prefix(object __instance, MethodBase __originalMethod)
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return true;
			}
			ItemData val = null;
			try
			{
				val = Traverse.Create(__instance).Property("Item", (object[])null).GetValue<ItemData>();
			}
			catch
			{
				return true;
			}
			if (__originalMethod.Name == "TryCatch" && (Object)(object)localPlayer.m_hoveringCreature != (Object)null)
			{
				return WardAccess.TryBlockItemUse(localPlayer, val, ((Component)localPlayer.m_hoveringCreature).transform.position);
			}
			return WardAccess.TryBlockItemUse(localPlayer, val);
		}
	}
	[HarmonyPatch]
	internal static class AzuCraftyBoxesNearbyContainersPatch
	{
		private sealed class ReferenceEqualityComparer : IEqualityComparer<object>
		{
			internal static readonly ReferenceEqualityComparer Instance = new ReferenceEqualityComparer();

			public new bool Equals(object? x, object? y)
			{
				return x == y;
			}

			public int GetHashCode(object obj)
			{
				return RuntimeHelpers.GetHashCode(obj);
			}
		}

		private const string AzuCraftyBoxesPluginGuid = "Azumatt.AzuCraftyBoxes";

		private static readonly Dictionary<Type, Func<object, Vector3>?> GetPositionDelegates = new Dictionary<Type, Func<object, Vector3>>();

		private static readonly Dictionary<object, bool> FrameBlockCache = new Dictionary<object, bool>(ReferenceEqualityComparer.Instance);

		private static readonly Type? ContainerInterfaceType = ResolveContainerInterfaceType();

		private static int _cachedFrame = -1;

		private static bool Prepare()
		{
			return ContainerInterfaceType != null;
		}

		private static IEnumerable<MethodBase> TargetMethods()
		{
			if (ContainerInterfaceType == null)
			{
				yield break;
			}
			foreach (Type loadableType in GetLoadableTypes(ContainerInterfaceType.Assembly))
			{
				if (!(loadableType == null) && !loadableType.IsAbstract && !loadableType.IsInterface && ContainerInterfaceType.IsAssignableFrom(loadableType))
				{
					MethodInfo methodInfo = AccessTools.DeclaredMethod(loadableType, "ItemCount", new Type[1] { typeof(string) }, (Type[])null);
					if (methodInfo != null)
					{
						yield return methodInfo;
					}
				}
			}
		}

		private static bool Prefix(object __instance, ref int __result)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || !WardAccess.HasEnabledManagedWards())
			{
				return true;
			}
			ResetFrameCacheIfNeeded();
			if (FrameBlockCache.TryGetValue(__instance, out var value))
			{
				if (!value)
				{
					return true;
				}
				__result = 0;
				return false;
			}
			if (!TryGetContainerPosition(__instance, out var position))
			{
				FrameBlockCache[__instance] = false;
				return true;
			}
			value = WardAccess.ShouldBlockRestriction(WardRestrictionOptions.Containers, position, 0f, localPlayer, flash: false);
			FrameBlockCache[__instance] = value;
			if (!value)
			{
				return true;
			}
			__result = 0;
			return false;
		}

		private static Type? ResolveContainerInterfaceType()
		{
			if (!Chainloader.PluginInfos.TryGetValue("Azumatt.AzuCraftyBoxes", out var value))
			{
				return null;
			}
			return ((object)value.Instance)?.GetType().Assembly.GetType("AzuCraftyBoxes.IContainers.IContainer");
		}

		private static IEnumerable<Type> GetLoadableTypes(Assembly assembly)
		{
			try
			{
				return assembly.GetTypes();
			}
			catch (ReflectionTypeLoadException ex)
			{
				if (ex.Types == null)
				{
					return Array.Empty<Type>();
				}
				List<Type> list = new List<Type>(ex.Types.Length);
				for (int i = 0; i < ex.Types.Length; i++)
				{
					if (ex.Types[i] != null)
					{
						list.Add(ex.Types[i]);
					}
				}
				return list;
			}
		}

		private static void ResetFrameCacheIfNeeded()
		{
			int frameCount = Time.frameCount;
			if (_cachedFrame != frameCount)
			{
				_cachedFrame = frameCount;
				FrameBlockCache.Clear();
			}
		}

		private static bool TryGetContainerPosition(object container, out Vector3 position)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			Type type = container.GetType();
			if (!GetPositionDelegates.TryGetValue(type, out Func<object, Vector3> value))
			{
				value = CreateGetPositionDelegate(type);
				GetPositionDelegates[type] = value;
			}
			if (value == null)
			{
				position = default(Vector3);
				return false;
			}
			try
			{
				position = value(container);
				return true;
			}
			catch
			{
			}
			position = default(Vector3);
			return false;
		}

		private static Func<object, Vector3>? CreateGetPositionDelegate(Type type)
		{
			MethodInfo methodInfo = AccessTools.Method(type, "GetPosition", (Type[])null, (Type[])null);
			if (methodInfo == null || methodInfo.IsStatic || methodInfo.ReturnType != typeof(Vector3) || methodInfo.GetParameters().Length != 0)
			{
				return null;
			}
			try
			{
				ParameterExpression parameterExpression = Expression.Parameter(typeof(object), "target");
				return Expression.Lambda<Func<object, Vector3>>(Expression.Call(Expression.Convert(parameterExpression, type), methodInfo), new ParameterExpression[1] { parameterExpression }).Compile();
			}
			catch
			{
				return null;
			}
		}
	}
	[HarmonyPatch(typeof(Player), "AutoPickup")]
	internal static class PlayerAutoPickupPatch
	{
		private const int MaxBufferedAutoPickupColliders = 4096;

		private static Collider[] _autoPickupColliders = (Collider[])(object)new Collider[64];

		private static readonly List<PrivateArea> AutoPickupWardCandidates = new List<PrivateArea>();

		private static readonly List<PrivateArea> DeniedAutoPickupWardCandidates = new List<PrivateArea>();

		private static void Prefix(Player __instance, out List<ItemDrop>? __state)
		{
			//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_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_005b: 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_00c1: Unknown result type (might be due to invalid IL or missing references)
			__state = null;
			if ((Object)(object)__instance == (Object)null || ((Character)__instance).IsTeleporting() || !Player.m_enableAutoPickup || !WardAccess.HasEnabledManagedWards() || !WardItemPrefabPolicy.CanAnyPickupBeBlocked())
			{
				return;
			}
			Vector3 val = ((Component)__instance).transform.position + Vector3.up;
			float autoPickupRange = __instance.m_autoPickupRange;
			AutoPickupWardCandidates.Clear();
			DeniedAutoPickupWardCandidates.Clear();
			WardAccess.FillCandidateManagedWards(val, autoPickupRange, requireEnabled: true, AutoPickupWardCandidates);
			if (WardAccess.CollectDeniedManagedWardCandidates(__instance.GetPlayerID(), AutoPickupWardCandidates, WardRestrictionOptions.Pickup, DeniedAutoPickupWardCandidates) == 0)
			{
				return;
			}
			List<ItemDrop> list = null;
			try
			{
				int colliderCount;
				Collider[] autoPickupColliders = GetAutoPickupColliders(__instance, val, autoPickupRange, out colliderCount);
				for (int i = 0; i < colliderCount; i++)
				{
					ItemDrop val2 = ResolveItemDrop(autoPickupColliders[i]);
					if (!((Object)(object)val2 == (Object)null) && val2.m_autoPickup && WardItemPrefabPolicy.ShouldBlockPickup(val2) && WardAccess.IsInsideAnyManagedWard(((Component)val2).transform.position, 0f, DeniedAutoPickupWardCandidates))
					{
						if (list == null)
						{
							list = new List<ItemDrop>();
						}
						list.Add(val2);
						val2.m_autoPickup = false;
					}
				}
				__state = list;
			}
			catch
			{
				RestoreAutoPickupItems(list);
				__state = null;
				throw;
			}
		}

		private static Exception? Finalizer(Exception? __exception, List<ItemDrop>? __state)
		{
			RestoreAutoPickupItems(__state);
			return __exception;
		}

		private static Collider[] GetAutoPickupColliders(Player player, Vector3 pickupPoint, float autoPickupRange, out int colliderCount)
		{
			//IL_0007: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			Collider[] autoPickupColliders = _autoPickupColliders;
			colliderCount = Physics.OverlapSphereNonAlloc(pickupPoint, autoPickupRange, autoPickupColliders, player.m_autoPickupMask);
			while (colliderCount == autoPickupColliders.Length && autoPickupColliders.Length < 4096)
			{
				Array.Resize(ref _autoPickupColliders, Math.Min(_autoPickupColliders.Length * 2, 4096));
				autoPickupColliders = _autoPickupColliders;
				colliderCount = Physics.OverlapSphereNonAlloc(pickupPoint, autoPickupRange, autoPickupColliders, player.m_autoPickupMask);
			}
			if (colliderCount != autoPickupColliders.Length)
			{
				return autoPickupColliders;
			}
			autoPickupColliders = Physics.OverlapSphere(pickupPoint, autoPickupRange, player.m_autoPickupMask);
			colliderCount = autoPickupColliders.Length;
			return autoPickupColliders;
		}

		private static ItemDrop? ResolveItemDrop(Collider? collider)
		{
			Rigidbody val = ((collider != null) ? collider.attachedRigidbody : null);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			ItemDrop component = ((Component)val).GetComponent<ItemDrop>();
			if ((Object)(object)component != (Object)null)
			{
				return component;
			}
			FloatingTerrainDummy component2 = ((Component)val).GetComponent<FloatingTerrainDummy>();
			if (!((Object)(object)component2?.m_parent != (Object)null))
			{
				return null;
			}
			return ((Component)component2.m_parent).GetComponent<ItemDrop>();
		}

		private static void RestoreAutoPickupItems(List<ItemDrop>? disabledItems)
		{
			if (disabledItems == null)
			{
				return;
			}
			for (int i = 0; i < disabledItems.Count; i++)
			{
				ItemDrop val = disabledItems[i];
				if ((Object)(object)val != (Object)null)
				{
					val.m_autoPickup = true;
				}
			}
		}
	}
	internal static class WardPatchHelpers
	{
		internal enum ProtectedRpcDecision
		{
			Allow,
			Deny,
			Unresolved
		}

		private sealed class StumpClassification
		{
			internal bool Initialized;

			internal string CachedName = string.Empty;

			internal bool IsLikelyStump;
		}

		private static readonly string[] StumpNameTokens = new string[3] { "stub", "stump", "stomp" };

		private static readonly ConditionalWeakTable<GameObject, StumpClassification> StumpClassificationCache = new ConditionalWeakTable<GameObject, StumpClassification>();

		internal static Piece? FindRemoveTarget(Player player)
		{
			//IL_0037: 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_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_00ae: Unknown result type (might be due to invalid IL or missing references)
			Piece hoveringPiece = player.GetHoveringPiece();
			if ((Object)(object)hoveringPiece != (Object)null)
			{
				return hoveringPiece;
			}
			GameCamera instance = GameCamera.instance;
			if ((Object)(object)instance == (Object)null || (Object)(object)((Character)player).m_eye == (Object)null)
			{
				return null;
			}
			RaycastHit val = default(RaycastHit);
			if (!Physics.Raycast(((Component)instance).transform.position, ((Component)instance).transform.forward, ref val, 50f, player.m_removeRayMask))
			{
				return null;
			}
			if (Vector3.Distance(((RaycastHit)(ref val)).point, ((Character)player).m_eye.position) >= player.m_maxPlaceDistance)
			{
				return null;
			}
			Piece componentInParent = ((Component)((RaycastHit)(ref val)).collider).GetComponentInParent<Piece>();
			if ((Object)(object)componentInParent != (Object)null)
			{
				return componentInParent;
			}
			if (!((Object)(object)((Component)((RaycastHit)(ref val)).collider).GetComponent<Heightmap>() != (Object)null))
			{
				return null;
			}
			return TerrainModifier.FindClosestModifierPieceInRange(((RaycastHit)(ref val)).point, 2.5f);
		}

		internal static bool ShouldBlockLocalRemoval(Piece? piece)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)piece == (Object)null || (Object)(object)localPlayer == (Object)null || !((Character)localPlayer).InPlaceMode())
			{
				return false;
			}
			if ((Object)(object)localPlayer.GetHoveringPiece() != (Object)(object)piece && (Object)(object)FindRemoveTarget(localPlayer) != (Object)(object)piece)
			{
				return false;
			}
			return ShouldBlockRemoval(piece, localPlayer);
		}

		internal static bool ShouldBlockRemoval(Piece? piece, Player? player)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)piece == (Object)null || (Object)(object)player == (Object)null)
			{
				return false;
			}
			PrivateArea component = ((Component)piece).GetComponent<PrivateArea>();
			if (!ManagedWardIdentity.EnsureManagedComponent(component))
			{
				return WardAccess.ShouldBlock(((Component)piece).transform.position, 0f, player);
			}
			return !WardAccess.HasManagedWardTrust(component, player.GetPlayerID());
		}

		internal static ProtectedRpcDecision EvaluateRemovalBySender(Piece? piece, long sender)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)piece == (Object)null)
			{
				return ProtectedRpcDecision.Allow;
			}
			if (!TryResolveAuthoritativeSenderPlayerId(sender, out var playerId))
			{
				return ProtectedRpcDecision.Unresolved;
			}
			PrivateArea component = ((Component)piece).GetComponent<PrivateArea>();
			if (ManagedWardIdentity.EnsureManagedComponent(component))
			{
				if (!WardAccess.HasManagedWardTrust(component, playerId))
				{
					return ProtectedRpcDecision.Deny;
				}
				return ProtectedRpcDecision.Allow;
			}
			if (!WardAccess.CheckAccess(((Component)piece).transform.position, 0f, playerId))
			{
				return ProtectedRpcDecision.Deny;
			}
			return ProtectedRpcDecision.Allow;
		}

		internal static bool IsPlacedConsumablePiece(Piece? piece)
		{
			if ((Object)(object)piece != (Object)null)
			{
				return WardAccess.IsPlacedConsumable(((Component)piece).GetComponent<ItemDrop>());
			}
			return false;
		}

		internal static ProtectedRpcDecision EvaluatePlacedConsumableRemovalBySender(Piece? piece, long sender)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)piece == (Object)null)
			{
				return ProtectedRpcDecision.Allow;
			}
			if (!TryResolveAuthoritativeSenderPlayerId(sender, out var playerId))
			{
				return ProtectedRpcDecision.Unresolved;
			}
			if (!WardAccess.CheckRestrictionAccess(WardRestrictionOptions.PlacedConsumables, ((Component)piece).transform.position, 0f, playerId))
			{
				return ProtectedRpcDecision.Deny;
			}
			return ProtectedRpcDecision.Allow;
		}

		internal static ProtectedRpcDecision EvaluateDamageBySender(Vector3 point, long sender)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			if (!TryResolveAuthoritativeSenderPlayerId(sender, out var playerId))
			{
				return ProtectedRpcDecision.Unresolved;
			}
			if (!WardAccess.CheckAccess(point, 0f, playerId))
			{
				return ProtectedRpcDecision.Deny;
			}
			return ProtectedRpcDecision.Allow;
		}

		internal static Piece? GetProtectedBuildingPiece(Component? target)
		{
			if ((Object)(object)target == (Object)null || IsLikelyStumpDestructible(target))
			{
				return null;
			}
			return target.GetComponent<Piece>();
		}

		internal static BuildingDamageBlockReason GetBuildingDamageBlockReason(Vector3 point, Piece? piece, long sender)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			if (!TryResolveAuthoritativeSenderPlayerId(sender, out var playerId))
			{
				return BuildingDamageBlockReason.UnresolvedSender;
			}
			return EvaluateBuildingDamagePolicy(point, piece, DamageSourceKind.Player, playerId);
		}

		internal static BuildingDamageBlockReason GetBuildingDamageBlockReason(Vector3 point, Piece? piece, HitData? hit, long sender)
		{
			//IL_001f: 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)
			Character val = ((hit != null) ? hit.GetAttacker() : null);
			if (!((Object)(object)val != (Object)null))
			{
				return GetBuildingDamageBlockReason(point, piece, sender);
			}
			return GetBuildingDamageBlockReason(point, piece, val);
		}

		internal static BuildingDamageBlockReason GetBuildingDamageBlockReason(Vector3 point, Piece? piece, Character? attacker)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return EvaluateBuildingDamagePolicy(point, piece, GetDamageSourceKind(attacker), GetPlayerIdFromCharacter(attacker));
		}

		internal static ProtectedRpcDecision EvaluateInteractionBySender(Vector3 point, long sender)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			if (!TryResolveAuthoritativeSenderPlayerId(sender, out var playerId))
			{
				return ProtectedRpcDecision.Unresolved;
			}
			if (!WardAccess.CheckAccess(point, 0f, playerId))
			{
				return ProtectedRpcDecision.Deny;
			}
			return ProtectedRpcDecision.Allow;
		}

		internal static ProtectedRpcDecision EvaluateInteractionBySender(Vector3 point, long sender, WardRestrictionOptions restriction)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (!TryResolveAuthoritativeSenderPlayerId(sender, out var playerId))
			{
				return ProtectedRpcDecision.Unresolved;
			}
			if (!WardAccess.CheckRestrictionAccess(restriction, point, 0f, playerId))
			{
				return ProtectedRpcDecision.Deny;
			}
			return ProtectedRpcDecision.Allow;
		}

		internal static bool ShouldBlockDamageByCharacter(Vector3 point, Character? attacker)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			long playerIdFromCharacter = GetPlayerIdFromCharacter(attacker);
			if (playerIdFromCharacter == 0L)
			{
				return false;
			}
			return !WardAccess.CheckAccess(point, 0f, playerIdFromCharacter);
		}

		private static BuildingDamageBlockReason EvaluateBuildingDamagePolicy(Vector3 point, Piece? piece, DamageSourceKind sourceKind, long playerId)
		{
			//IL_000a: 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)
			bool num = (Object)(object)piece != (Object)null;
			bool insideEnabledWard = num && (Object)(object)WardAccess.FindNearestManagedWard(point) != (Object)null;
			bool blocksHostileCreatureDamage = num && sourceKind == DamageSourceKind.MonsterAI && WardAccess.ShouldBlockHostileCreatureDamageToBuilding(point);
			bool playerHasAccess = playerId == 0L || !WardAccess.EvaluateAccess(point, 0f, playerId, flash: false).IsDenied;
			return BuildingDamagePolicy.Evaluate(new BuildingDamagePolicyInput(num, sourceKind, playerId, insideEnabledWard, blocksHostileCreatureDamage, playerHasAccess));
		}

		private static DamageSourceKind GetDamageSourceKind(Character? attacker)
		{
			if (attacker is Player)
			{
				return DamageSourceKind.Player;
			}
			if ((Object)(object)attacker != (Object)null && attacker.IsTamed())
			{
				return DamageSourceKind.TamedCreature;
			}
			if (((attacker != null) ? attacker.GetBaseAI() : null) is MonsterAI)
			{
				return DamageSourceKind.MonsterAI;
			}
			return DamageSourceKind.Unknown;
		}

		internal static Player? GetLocalPlayerForCharacter(Character? attacker)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return null;
			}
			if (localPlayer.GetPlayerID() != GetPlayerIdFromCharacter(attacker))
			{
				return null;
			}
			return localPlayer;
		}

		internal static Player? GetLocalPlayerForSender(long sender)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return null;
			}
			if (localPlayer.GetPlayerID() != GetPlayerIdFromSender(sender))
			{
				return null;
			}
			return localPlayer;
		}

		private static bool TryResolveAuthoritativeSenderPlayerId(long sender, out long playerId)
		{
			return WardOwnership.TryResolveAuthoritativePlayerIdFromSender(sender, out playerId);
		}

		private static long GetPlayerIdFromCharacter(Character? attacker)
		{
			if (attacker != null)
			{
				Player val = (Player)(object)((attacker is Player) ? attacker : null);
				if (val != null)
				{
					return val.GetPlayerID();
				}
				if (!attacker.IsTamed())
				{
					return 0L;
				}
				long owner = attacker.GetOwner();
				if (owner == 0L)
				{
					return 0L;
				}
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer != (Object)null && ((Character)localPlayer).GetOwner() == owner)
				{
					return localPlayer.GetPlayerID();
				}
				return GetPlayerIdFromSender(owner);
			}
			return 0L;
		}

		private static long GetPlayerIdFromSender(long sender)
		{
			return WardOwnership.GetPlayerIdFromSender(sender);
		}

		private static bool IsLikelyStumpDestructible(Component target)
		{
			GameObject gameObject = target.gameObject;
			StumpClassification orCreateValue = StumpClassificationCache.GetOrCreateValue(gameObject);
			string text = ((Object)gameObject).name ?? string.Empty;
			if (!orCreateValue.Initialized || !string.Equals(orCreateValue.CachedName, text, StringComparison.Ordinal))
			{
				orCreateValue.CachedName = text;
				orCreateValue.IsLikelyStump = ComputeIsLikelyStumpDestructible(gameObject, text);
				orCreateValue.Initialized = true;
			}
			return orCreateValue.IsLikelyStump;
		}

		private static bool ComputeIsLikelyStumpDestructible(GameObject target, string targetName)
		{
			if ((Object)(object)target.GetComponent<Destructible>() != (Object)null && (Object)(object)target.GetComponent<StaticPhysics>() != (Object)null)
			{
				return IsLikelyStumpName(targetName);
			}
			return false;
		}

		private static bool IsLikelyStumpName(string name)
		{
			if (string.IsNullOrWhiteSpace(name))
			{
				return false;
			}
			string text = NormalizeName(name);
			for (int i = 0; i < StumpNameTokens.Length; i++)
			{
				if (text.IndexOf(StumpNameTokens[i], StringComparison.Ordinal) >= 0)
				{
					return true;
				}
			}
			return false;
		}

		private static string NormalizeName(string name)
		{
			string text = name.Trim();
			int num = text.IndexOf("(Clone)", StringComparison.OrdinalIgnoreCase);
			if (num >= 0)
			{
				text = text.Substring(0, num);
			}
			return text.Trim().ToLowerInvariant();
		}
	}
	[Flags]
	internal enum WardRestrictionOptions
	{
		None = 0,
		Doors = 1,
		Portals = 2,
		Pickup = 4,
		PlacedConsumables = 8,
		ItemStands = 0x10,
		ArmorStands = 0x20,
		Containers = 0x40,
		CraftingStations = 0x80,
		TameablesAndSaddles = 0x100,
		All = 0x1FF
	}
	internal readonly struct WardRestrictionDefinition
	{
		internal WardRestrictionOptions Restriction { get; }

		internal string ConfigName { get; }

		internal string ConfigDescription { get; }

		internal string LocalizationToken { get; }

		internal string LocalizationFallback { get; }

		internal WardRestrictionDefinition(WardRestrictionOptions restriction, string configName, string configDescription, string localizationToken, string localizationFallback)
		{
			Restriction = restriction;
			ConfigName = configName;
			ConfigDescription = configDescription;
			LocalizationToken = localizationToken;
			LocalizationFallback = localizationFallback;
		}
	}
	internal readonly struct WardConfiguration
	{
		internal float Radius { get; }

		internal bool AreaMarkerRotationEnabled { get; }

		internal bool AutoCloseEnabled { get; }

		internal bool WarningSoundEnabled { get; }

		internal bool WarningFlashEnabled { get; }

		internal WardRestrictionOptions Restrictions { get; }

		internal WardConfiguration(float radius, bool areaMarkerRotationEnabled, bool autoCloseEnabled, bool warningSoundEnabled, bool warningFlashEnabled, WardRestrictionOptions restrictions = WardRestrictionOptions.All)
		{
			Radius = radius;
			AreaMarkerRotationEnabled = areaMarkerRotationEnabled;
			AutoCloseEnabled = autoCloseEnabled;
			WarningSoundEnabled = warningSoundEnabled;
			WarningFlashEnabled = warningFlashEnabled;
			Restrictions = restrictions;
		}
	}
	internal readonly struct CachedWardConfiguration
	{
		internal uint DataRevision { get; }

		internal float MaxRadius { get; }

		internal WardRestrictionOptions ForcedRestrictions { get; }

		internal WardConfiguration Configuration { get; }

		internal CachedWardConfiguration(uint dataRevision, float maxRadius, WardRestrictionOptions forcedRestrictions, WardConfiguration configuration)
		{
			DataRevision = dataRevision;
			MaxRadius = maxRadius;
			ForcedRestrictions = forcedRestrictions;
			Configuration = configuration;
		}
	}
	internal readonly struct CachedAreaMarkerVisualState
	{
		internal int MarkerInstanceId { get; }

		internal int SegmentCount { get; }

		internal int FirstSegmentInstanceId { get; }

		internal int LastSegmentInstanceId { get; }

		internal float MaxRadius { get; }

		internal float Radius { get; }

		internal CachedAreaMarkerVisualState(int markerInstanceId, int segmentCount, int firstSegmentInstanceId, int lastSegmentInstanceId, float maxRadius, float radius)
		{
			MarkerInstanceId = markerInstanceId;
			SegmentCount = segmentCount;
			FirstSegmentInstanceId = firstSegmentInstanceId;
			LastSegmentInstanceId = lastSegmentInstanceId;
			MaxRadius = maxRadius;
			Radius = radius;
		}
	}
	internal enum WardConfigurationRequestResultCode
	{
		Applied,
		Unchanged,
		Denied,
		InvalidPayload,
		InvalidState
	}
	internal readonly struct WardConfigurationRequestSubmission
	{
		internal bool IsPending { get; }

		internal long RequestId { get; }

		internal WardConfigurationRequestResultCode ResultCode { get; }

		internal WardConfiguration Configuration { get; }

		internal WardConfigurationRequestSubmission(bool isPending, long requestId, WardConfigurationRequestResultCode resultCode, WardConfiguration configuration)
		{
			IsPending = isPending;
			RequestId = requestId;
			ResultCode = resultCode;
			Configuration = configuration;
		}
	}
	internal readonly struct WardConfigurationUpdateResult
	{
		internal WardConfigurationRequestResultCode ResultCode { get; }

		internal WardConfiguration Configuration { get; }

		internal WardConfigurationUpdateResult(WardConfigurationRequestResultCode resultCode, WardConfiguration configuration)
		{
			ResultCode = resultCode;
			Configuration = configuration;
		}
	}
	internal static class WardSettings
	{
		internal const int ManagedAreaMarkerSegments = 36;

		private const float ManagedAreaMarkerSegmentLengthMultiplier = 2f;

		internal const float MinRadius = 8f;

		internal const float MaxRadiusLimit = 64f;

		internal const float DefaultMaxRadius = 32f;

		internal const bool DefaultAreaMarkerRotationEnabled = true;

		internal const bool DefaultAutoCloseEnabled = true;

		internal const bool DefaultWarningSoundEnabled = true;

		internal const bool DefaultWarningFlashEnabled = true;

		private const float WarningEffectCooldownSeconds = 0.5f;

		private const float AreaMarkerBoundaryFlashSeconds = 0.5f;

		private const float AreaMarkerBoundaryHoldDistance = 0.75f;

		private const float PlacementBlockerHighlightSeconds = 1.5f;

		private const string RpcUpdateSettings = "STUWard_UpdateSettings";

		private const string RpcUpdateSettingsResponse = "STUWard_UpdateSettingsResponse";

		private const string RpcRemovePermitted = "STUWard_RemovePermitted";

		internal const string RadiusKey = "stuw_radius";

		private const string AreaMarkerRotationEnabledKey = "stuw_area_marker_rotation_enabled";

		private const string AutoCloseEnabledKey = "stuw_auto_close_enabled";

		private const string WarningSoundEnabledKey = "stuw_warning_sound_enabled";

		private const string WarningFlashEnabledKey = "stuw_warning_flash_enabled";

		private const string RestrictionOptionsKey = "stuw_restriction_options";

		private const float MinimumAreaMarkerBrightness = 0.35f;

		private const float FallbackNativeAreaMarkerSpeed = 0.1f;

		private const float EnabledAreaMarkerSpeedMultiplier = 0.5f;

		private static readonly string[] AreaMarkerColorProperties = new string[3] { "_Color", "_BaseColor", "_TintColor" };

		private static readonly MaterialPropertyBlock AreaMarkerPropertyBlock = new MaterialPropertyBlock();

		private static readonly List<PrivateArea> BoundaryFlashPreviousCandidates = new List<PrivateArea>();

		private static readonly List<PrivateArea> BoundaryFlashCurrentCandidates = new List<PrivateArea>();

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

		private static readonly List<PrivateArea> ActiveAreaMarkerBrightnessAreas = new List<PrivateArea>();

		private static bool _hasBoundaryFlashPlayerPosition;

		private static int _boundaryFlashPlayerInstanceId;

		private static Vector3 _boundaryFlashPlayerPosition;

		private static readonly WardRestrictionDefinition[] RestrictionDefinitionValues = new WardRestrictionDefinition[9]
		{
			new WardRestrictionDefinition(WardRestrictionOptions.Doors, "Doors", "Controls whether door interaction is always blocked by foreign enabled wards or can be turned off per ward.", "$stuw_ui_restriction_doors", "Doors"),
			new WardRestrictionDefinition(WardRestrictionOptions.Portals, "Portals", "Controls whether portal entry and TargetPortal routing are always blocked by foreign enabled wards or can be turned off per ward.", "$stuw_ui_restriction_portals", "Portals"),
			new WardRestrictionDefinition(WardRestrictionOptions.Pickup, "Pickup", "Controls whether normal item pickup is always blocked by foreign enabled wards or can be turned off per ward.", "$stuw_ui_restriction_pickup", "Pickup"),
			new WardRestrictionDefinition(WardRestrictionOptions.PlacedConsumables, "Placed Consumables", "Controls whether eating hammer-placed consumables and feasts is always blocked by foreign enabled wards or can be turned off per ward.", "$stuw_ui_restriction_placed_consumables", "Consumables"),
			new WardRestrictionDefinition(WardRestrictionOptions.ItemStands, "Item Stands", "Controls whether item stand interaction is always blocked by foreign enabled wards or can be turned off per ward.", "$stuw_ui_restriction_item_stands", "Item stands"),
			new WardRestrictionDefinition(WardRestrictionOptions.ArmorStands, "Armor Stands", "Controls whether armor stand item placement is always blocked by foreign enabled wards or can be turned off per ward.", "$stuw_ui_restriction_armor_stands", "Armor stands"),
			new WardRestrictionDefinition(WardRestrictionOptions.Containers, "Containers", "Controls whether container interaction and remote container access are always blocked by foreign enabled wards or can be turned off per ward.", "$stuw_ui_restriction_containers", "Containers"),
			new WardRestrictionDefinition(WardRestrictionOptions.CraftingStations, "Crafting Stations", "Controls whether crafting station interaction is always blocked by foreign enabled wards or can be turned off per ward.", "$stuw_ui_restriction_crafting_stations", "Crafting stations"),
			new WardRestrictionDefinition(WardRestrictionOptions.TameablesAndSaddles, "Tameables And Saddles", "Controls whether tameable and saddle interaction is always blocked by foreign enabled wards or can be turned off per ward.", "$stuw_ui_restriction_tameables_and_saddles", "Tames")
		};

		private static long _nextConfigurationRequestId = 1L;

		internal static IReadOnlyList<WardRestrictionDefinition> RestrictionDefinitions => RestrictionDefinitionValues;

		internal static float MaxRadius => Mathf.Clamp(Plugin.MaxWardRadius?.Value ?? 32f, 8f, 64f);

		internal static WardRestrictionOptions ForcedRestrictions
		{
			get
			{
				WardRestrictionOptions restrictions = WardRestrictionOptions.None;
				for (int i = 0; i < RestrictionDefinitionValues.Length; i++)
				{
					WardRestrictionDefinition wardRestrictionDefinition = RestrictionDefinitionValues[i];
					AddForcedRestriction(ref restrictions, wardRestrictionDefinition.Restriction, GetRestrictionConfigEntry(wardRestrictionDefinition.Restriction));
				}
				return restrictions;
			}
		}

		internal static void RegisterRoutedRpcs(ZRoutedRpc routedRpc)
		{
			routedRpc.Register<ZPackage>("STUWard_UpdateSettings", (Action<long, ZPackage>)HandleRoutedUpdateConfiguration);
			routedRpc.Register<ZPackage>("STUWard_UpdateSettingsResponse", (Action<long, ZPackage>)HandleRoutedUpdateConfigurationResponse);
			routedRpc.Register<ZPackage>("STUWard_RemovePermitted", (Action<long, ZPackage>)HandleRoutedRemovePermitted);
		}

		internal static bool IsRestrictionForced(WardRestrictionOptions restriction)
		{
			return (ForcedRestrictions & restriction) != 0;
		}

		internal static bool HasRestriction(WardConfiguration configuration, WardRestrictionOptions restriction)
		{
			return (configuration.Restrictions & restriction) != 0;
		}

		internal static WardConfiguration WithRestriction(WardConfiguration configuration, WardRestrictionOptions restriction, bool enabled)
		{
			WardRestrictionOptions restrictions = (enabled ? (configuration.Restrictions | restriction) : (configuration.Restrictions & ~restriction));
			return WithRestrictions(configuration, restrictions);
		}

		internal static WardConfiguration WithAutoCloseEnabled(WardConfiguration configuration, bool enabled)
		{
			bool? autoCloseEnabled = enabled;
			return CopyConfiguration(configuration, null, null, autoCloseEnabled);
		}

		internal static WardConfiguration WithAreaMarkerRotationEnabled(WardConfiguration configuration, bool enabled)
		{
			bool? areaMarkerRotationEnabled = enabled;
			return CopyConfiguration(configuration, null, areaMarkerRotationEnabled);
		}

		internal static WardConfiguration WithRestrictions(WardConfiguration configuration, WardRestrictionOptions restrictions)
		{
			WardRestrictionOptions? restrictions2 = NormalizeRestrictions(restrictions);
			return CopyConfiguration(configuration, null, null, null, null, null, restrictions2);
		}

		private static WardConfiguration CopyConfiguration(WardConfiguration configuration, float? radius = null, bool? areaMarkerRotationEnabled = null, bool? autoCloseEnabled = null, bool? warningSoundEnabled = null, bool? warningFlashEnabled = null, WardRestrictionOptions? restrictions = null)
		{
			return new WardConfiguration(radius ?? configuration.Radius, areaMarkerRotationEnabled ?? configuration.AreaMarkerRotationEnabled, autoCloseEnabled ?? configuration.AutoCloseEnabled, warningSoundEnabled ?? configuration.WarningSoundEnabled, warningFlashEnabled ?? configuration.WarningFlashEnabled, restrictions ?? configuration.Restrictions);
		}

		private static void AddForcedRestriction(ref WardRestrictionOptions restrictions, WardRestrictionOptions restriction, ConfigEntry<Plugin.RestrictionServerMode>? config)
		{
			if (config != null && config.Value == Plugin.RestrictionServerMode.ForcedOn)
			{
				restrictions |= restriction;
			}
		}

		private static ConfigEntry<Plugin.RestrictionServerMode>? GetRestrictionConfigEntry(WardRestrictionOptions restriction)
		{
			if (!Plugin.RestrictionModes.TryGetValue(restriction, out ConfigEntry<Plugin.RestrictionServerMode> value))
			{
				return null;
			}
			return value;
		}

		internal static void CaptureNativeAreaMarkerSpeed(PrivateArea area)
		{
			ManagedWardRuntimeContext orCreate = ManagedWardRuntimeContexts.GetOrCreate(area);
			if (!orCreate.HasNativeAreaMarkerSpeed)
			{
				CircleProjector areaMarker = area.m_areaMarker;
				float num = (((Object)(object)areaMarker != (Object)null) ? areaMarker.m_speed : 0.1f);
				if (float.IsNaN(num) || float.IsInfinity(num))
				{
					num = 0.1f;
				}
				orCreate.NativeAreaMarkerSpeed = num;
				orCreate.HasNativeAreaMarkerSpeed = true;
			}
		}

		private static float GetAreaMarkerSpeed(PrivateArea area, bool rotationEnabled)
		{
			if (!rotationEnabled)
			{
				return 0f;
			}
			ManagedWardRuntimeContext context;
			return ((ManagedWardRuntimeContexts.TryGet(area, out context) && context.HasNativeAreaMarkerSpeed) ? context.NativeAreaMarkerSpeed : 0.1f) * 0.5f;
		}

		internal static void HandleMaxRadiusChanged()
		{
			ClampStoredRadiiToServerMaximum();
			ManagedWardRuntimeContexts.ClearConfigurationCaches();
			List<PrivateArea> allAreas = PrivateArea.m_allAreas;
			if (allAreas == null)
			{
				return;
			}
			for (int i = 0; i < allAreas.Count; i++)
			{
				ManagedWardRef ward = ManagedWardRef.FromArea(allAreas[i]);
				if (WardAccess.IsManagedWard(ward, requireEnabled: false))
				{
					ApplyAreaState(ward);
				}
			}
			ManagedWardMapStateService.InvalidateProjection();
		}

		internal static void ClampStoredRadiiToServerMaximum()
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || ZDOMan.instance == null)
			{
				return;
			}
			float maxRadius = MaxRadius;
			float num2 = default(float);
			foreach (ZDO value in ZDOMan.instance.m_objectsByID.Values)
			{
				if (value != null && WardOwnership.IsManagedWardZdo(value) && WardOwnership.IsAcceptedManagedWard(value))
				{
					float storedRadius = GetStoredRadius(value);
					bool num = value.GetFloat("stuw_radius", ref num2) && !float.IsNaN(num2) && !float.IsInfinity(num2) && Mathf.Approximately(num2, storedRadius);
					float num3 = Mathf.Min(storedRadius, maxRadius);
					if ((!num || !(storedRadius <= maxRadius)) && WardOwnership.TryClaimManagedWardMutationOwnership(value))
					{
						value.Set("stuw_radius", num3);
						WardOwnership.CompleteAuthoritativeManagedWardMutation(value);
					}
				}
			}
		}

		internal static WardConfiguration GetConfiguration(PrivateArea area)
		{
			ZDO zdo = GetZdo(area);
			float maxRadius = MaxRadius;
			WardRestrictionOptions forcedRestrictions = ForcedRestrictions;
			if (zdo != null)
			{
				uint dataRevision = zdo.DataRevision;
				ManagedWardRuntimeContext orCreate = ManagedWardRuntimeContexts.GetOrCreate(area);
				if (orCreate.HasCachedConfiguration)
				{
					CachedWardConfiguration cachedConfiguration = orCreate.CachedConfiguration;
					if (cachedConfiguration.DataRevision == dataRevision && Mathf.Approximately(cachedConfiguration.MaxRadius, maxRadius) && cachedConfiguration.ForcedRestrictions == forcedRestrictions)
					{
						return cachedConfiguration.Configuration;
					}
				}
			}
			WardConfiguration wardConfiguration = ReadConfiguration(zdo, maxRadius, forcedRestrictions);
			if (zdo != null)
			{
				ManagedWardRuntimeContext orCreate2 = ManagedWardRuntimeContexts.GetOrCreate(area);
				orCreate2.CachedConfiguration = new CachedWardConfiguration(zdo.DataRevision, maxRadius, forcedRestrictions, wardConfiguration);
				orCreate2.HasCachedConfiguration = true;
			}
			return wardConfiguration;
		}

		private static WardConfiguration GetConfiguration(ZDO? zdo)
		{
			return ReadConfiguration(zdo, MaxRadius, ForcedRestrictions);
		}

		private static WardConfiguration ReadConfiguration(ZDO? zdo, float maxRadius, WardRestrictionOptions forcedRestrictions)
		{
			float radius = Mathf.Min(GetStoredRadius(zdo), maxRadius);
			bool areaMarkerRotationEnabled = zdo == null || zdo.GetBool("stuw_area_marker_rotation_enabled", true);
			bool autoCloseEnabled = zdo == null || zdo.GetBool("stuw_auto_close_enabled", true);
			bool warningSoundEnabled = zdo == null || zdo.GetBool("stuw_warning_sound_enabled", true);
			bool warningFlashEnabled = zdo == null || zdo.GetBool("stuw_warning_flash_enabled", true);
			WardRestrictionOptions restrictions = ApplyForcedRestrictions(NormalizeRestrictions((zdo != null) ? ((WardRestrictionOptions)zdo.GetInt("stuw_restriction_options", 511)) : WardRestrictionOptions.All), forcedRestrictions);
			return new WardConfiguration(radius, areaMarkerRotationEnabled, autoCloseEnabled, warningSoundEnabled, warningFlashEnabled, restrictions);
		}

		internal static void ApplyAreaState(ManagedWardRef ward)
		{
			PrivateArea area = ward.Area;
			if (!((Object)(object)area == (Object)null))
			{
				ApplyAreaState(ward, GetConfiguration(area));
			}
		}

		internal static void ApplyAreaState(ManagedWardRef ward, WardConfiguration configuration)
		{
			PrivateArea area = ward.Area;
			if ((Object)(object)area == (Object)null)
			{
				return;
			}
			bool num = !Mathf.Approximately(area.m_radius, configuration.Radius);
			if (num)
			{
				area.m_radius = configuration.Radius;
			}
			CircleProjector areaMarker = area.m_areaMarker;
			if ((Object)(object)areaMarker == (Object)null)
			{
				InvalidateAreaMarkerVisuals(area);
			}
			else
			{
				bool visible = ShouldShowAreaMarker(area);
				if (areaMarker.m_nrOfSegments != 36)
				{
					areaMarker.m_nrOfSegments = 36;
				}
				if (!Mathf.Approximately(areaMarker.m_radius, configuration.Radius))
				{
					areaMarker.m_radius = configuration.Radius;
				}
				float areaMarkerSpeed = GetAreaMarkerSpeed(area, configuration.AreaMarkerRotationEnabled);
				if (!Mathf.Approximately(areaMarker.m_speed, areaMarkerSpeed))
				{
					areaMarker.m_speed = areaMarkerSpeed;
				}
				ApplyManagedAreaMarkerVisibility(area, visible);
				if (ShouldRefreshAreaMarkerVisuals(area, areaMarker, configuration))
				{
					ApplyAreaMarkerVisuals(area, areaMarker, configuration);
					CacheAreaMarkerVisualState(area, areaMarker, configuration);
				}
			}
			if (num)
			{
				ManagedWardPresenceService.Invalidate();
				ManagedWardPlacementPreviewService.Invalidate();
				WardAccess.RefreshManagedWardSpatialIndexEntry(ward);
			}
		}

		internal static void ApplyPlacementGhostPreviewRadius(PrivateArea area)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)area == (Object)null || !Player.IsPlacementGhost(((Component)area).gameObject))
			{
				return;
			}
			WardAccess.TryGetAutomaticPlacementRadius(Player.m_localPlayer, ((Component)area).transform.position, out var radius);
			float num = Mathf.Clamp(radius, 8f, MaxRadius);
			if (!Mathf.Approximately(area.m_radius, num))
			{
				area.m_radius = num;
			}
			if (Object.op_Implicit((Object)(object)area.m_areaMarker))
			{
				if (area.m_areaMarker.m_nrOfSegments != 36)
				{
					area.m_areaMarker.m_nrOfSegments = 36;
				}
				if (!Mathf.Approximately(area.m_areaMarker.m_radius, num))
				{
					area.m_areaMarker.m_radius = num;
				}
				if (!Mathf.Approximately(area.m_areaMarker.m_speed, 0f))
				{
					area.m_areaMarker.m_speed = 0f;
				}
			}
		}

		internal static bool ShouldShowAreaMarker(PrivateArea area)
		{
			if (!ShouldNormallyShowAreaMarker(area))
			{
				return IsPlacementBlockerHighlightActive(area);
			}
			return true;
		}

		private static bool ShouldNormallyShowAreaMarker(PrivateArea area)
		{
			if (!Player.IsPlacementGhost(((Component)area).gameObject))
			{
				return area.IsEnabled();
			}
			return true;
		}

		internal static void ShowManagedAreaMarker(PrivateArea area)
		{
			if (!((Object)(object)area == (Object)null) && !((Object)(object)area.m_areaMarker == (Object)null))
			{
				((MonoBehaviour)area).CancelInvoke("HideMarker");
				((Component)area.m_areaMarker).gameObject.SetActive(true);
			}
		}

		internal static void InvalidateAreaMarkerVisuals(PrivateArea? area)
		{
			ManagedWardRuntimeContexts.ClearAreaMarkerVisualState(area);
		}

		internal static void ResetLocalBoundaryFlashState()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			_hasBoundaryFlashPlayerPosition = false;
			_boundaryFlashPlayerInstanceId = 0;
			_boundaryFlashPlayerPosition = default(Vector3);
			BoundaryFlashPreviousCandidates.Clear();
			BoundaryFlashCurrentCandidates.Clear();
			BoundaryFlashCandidateIds.Clear();
			ActiveAreaMarkerBrightnessAreas.Clear();
		}

		internal static void HandleLocalBoundaryBrightenModeChanged()
		{
			float unscaledTime = Time.unscaledTime;
			for (int num = ActiveAreaMarkerBrightnessAreas.Count - 1; num >= 0; num--)
			{
				PrivateArea val = ActiveAreaMarkerBrightnessAreas[num];
				if ((Object)(object)val == (Object)null || !ManagedWardRuntimeContexts.TryGet(val, out ManagedWardRuntimeContext context))
				{
					ActiveAreaMarkerBrightnessAreas.RemoveAt(num);
				}
				else
				{
					context.AreaMarkerBoundaryFlashUntil = float.NegativeInfinity;
					if (!(unscaledTime < context.AreaMarkerPlacementHighlightUntil))
					{
						context.AreaMarkerPlacementHighlightUntil = float.NegativeInfinity;
						ActiveAreaMarkerBrightnessAreas.RemoveAt(num);
						RefreshAreaMarkerVisuals(val);
					}
				}
			}
			ResetBoundaryTrackingState();
		}

		internal static void UpdateLocalBoundaryFlash()
		{
			//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_006e: 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_00a9: 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_00b8: 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_00c6: 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_00d5: 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_0135: 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_0147: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			long playerId = (((Object)(object)localPlayer != (Object)null) ? localPlayer.GetPlayerID() : 0);
			Plugin.BoundaryBrightenMode boundaryBrightenMode = GetBoundaryBrightenMode();
			UpdateActiveAreaMarkerBrightness(playerId, boundaryBrightenMode);
			if ((Object)(object)localPlayer == (Object)null)
			{
				ResetBoundaryTrackingState();
				return;
			}
			if (((Character)localPlayer).IsTeleporting() || ((Character)localPlayer).IsDead())
			{
				ResetBoundaryTrackingState();
				return;
			}
			if (!IsBoundaryBrightenModeEnabled(boundaryBrightenMode))
			{
				ResetBoundaryTrackingState();
				return;
			}
			int instanceID = ((Object)localPlayer).GetInstanceID();
			Vector3 position = ((Component)localPlayer).transform.position;
			WardAccess.FillCandidateManagedWards(position, 0.75f, requireEnabled: true, BoundaryFlashCurrentCandidates);
			MaintainBoundaryBrightness(BoundaryFlashCurrentCandidates, position, playerId, boundaryBrightenMode);
			if (!_hasBoundaryFlashPlayerPosition || _boundaryFlashPlayerInstanceId != instanceID)
			{
				_hasBoundaryFlashPlayerPosition = true;
				_boundaryFlashPlayerInstanceId = instanceID;
				_boundaryFlashPlayerPosition = position;
				return;
			}
			Vector3 boundaryFlashPlayerPosition = _boundaryFlashPlayerPosition;
			_boundaryFlashPlayerPosition = position;
			float num = position.x - boundaryFlashPlayerPosition.x;
			float num2 = position.z - boundaryFlashPlayerPosition.z;
			float num3 = num * num + num2 * num2;
			if (!(num3 <= 0.0001f))
			{
				float num4 = Mathf.Max(8f, MaxRadius) * 2f;
				if (!(num3 > num4 * num4))
				{
					WardAccess.FillCandidateManagedWards(boundaryFlashPlayerPosition, 0f, requireEnabled: true, BoundaryFlashPreviousCandidates);
					BoundaryFlashCandidateIds.Clear();
					DetectBoundaryCrossings(BoundaryFlashPreviousCandidates, boundaryFlashPlayerPosition, position, playerId, boundaryBrightenMode);
					DetectBoundaryCrossings(BoundaryFlashCurrentCandidates, boundaryFlashPlayerPosition, position, playerId, boundaryBrightenMode);
				}
			}
		}

		private static void MaintainBoundaryBrightness(IReadOnlyList<PrivateArea> candidates, Vector3 playerPosition, long playerId, Plugin.BoundaryBrightenMode mode)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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)
			for (int i = 0; i < candidates.Count; i++)
			{
				PrivateArea val = candidates[i];
				if (!((Object)(object)val == (Object)null) && val.IsEnabled() && ShouldBrightenBoundary(val, playerId, mode))
				{
					Vector3 position = ((Component)val).transform.position;
					float num = playerPosition.x - position.x;
					float num2 = playerPosition.z - position.z;
					float num3 = num * num + num2 * num2;
					float num4 = Mathf.Max(0f, val.m_radius);
					float num5 = Mathf.Max(0f, num4 - 0.75f);
					float num6 = num4 + 0.75f;
					if (!(num3 < num5 * num5) && !(num3 > num6 * num6))
					{
						StartBoundaryFlash(val);
					}
				}
			}
		}

		private static void DetectBoundaryCrossings(IReadOnlyList<PrivateArea> candidates, Vector3 previousPosition, Vector3 currentPosition, long playerId, Plugin.BoundaryBrightenMode mode)
		{
			//IL_003b: 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)
			for (int i = 0; i < candidates.Count; i++)
			{
				PrivateArea val = candidates[i];
				if (!((Object)(object)val == (Object)null) && val.IsEnabled() && BoundaryFlashCandidateIds.Add(((Object)val).GetInstanceID()) && ShouldBrightenBoundary(val, playerId, mode) && val.IsInside(previousPosition, 0f) != val.IsInside(currentPosition, 0f))
				{
					StartBoundaryFlash(val);
				}
			}
		}

		private static void StartBoundaryFlash(PrivateArea area)
		{
			if (!((Object)(object)area.m_areaMarker == (Object)null) && ShouldNormallyShowAreaMarker(area))
			{
				ManagedWardRuntimeContext orCreate = ManagedWardRuntimeContexts.GetOrCreate(area);
				float unscaledTime = Time.unscaledTime;
				bool num = IsAreaMarkerBrightnessActive(area, orCreate, unscaledTime);
				orCreate.AreaMarkerBoundaryFlashUntil = unscaledTime + 0.5f;
				EnsureAreaMarkerBrightnessTracked(area);
				if (!num)
				{
					RefreshAreaMarkerVisuals(area);
				}
			}
		}

		internal static void HighlightPlacementBlockingWard(PrivateArea? area)
		{
			if (!((Object)(object)area == (Object)null) && !((Object)(object)area.m_areaMarker == (Object)null) && WardAccess.IsManagedWard(area, requireEnabled: false))
			{
				ManagedWardRuntimeContext orCreate = ManagedWardRuntimeContexts.GetOrCreate(area);
				float unscaledTime = Time.unscaledTime;
				bool num = IsAreaMarkerBrightnessActive(area, orCreate, unscaledTime);
				orCreate.AreaMarkerPlacementHighlightUntil = unscaledTime + 1.5f;
				EnsureAreaMarkerBrightnessTracked(area);
				if (!num)
				{
					RefreshAreaMarkerVisuals(area);
				}
			}
		}

		private static void UpdateActiveAreaMarkerBrightness(long playerId, Plugin.BoundaryBrightenMode mode)
		{
			float unscaledTime = Time.unscaledTime;
			for (int num = ActiveAreaMarkerBrightnessAreas.Count - 1; num >= 0; num--)
			{
				PrivateArea val = ActiveAreaMarkerBrightnessAreas[num];
				if ((Object)(object)val == (Object)null || !ManagedWardRuntimeContexts.TryGet(val, out ManagedWardRuntimeContext context))
				{
					ActiveAreaMarkerBrightnessAreas.RemoveAt(num);
					continue;
				}
				int num2;
				if (val.IsEnabled() && unscaledTime < context.AreaMarkerBoundaryFlashUntil && ShouldNormallyShowAreaMarker(val))
				{
					num2 = (ShouldBrightenBoundary(val, playerId, mode) ? 1 : 0);
					if (num2 != 0)
					{
						goto IL_0076;
					}
				}
				else
				{
					num2 = 0;
				}
				context.AreaMarkerBoundaryFlashUntil = float.NegativeInfinity;
				goto IL_0076;
				IL_0076:
				bool flag = unscaledTime < context.AreaMarkerPlacementHighlightUntil;
				if (((uint)num2 | (flag ? 1u : 0u)) == 0)
				{
					context.AreaMarkerBoundaryFlashUntil = float.NegativeInfinity;
					context.AreaMarkerPlacementHighlightUntil = float.NegativeInfinity;
					ActiveAreaMarkerBrightnessAreas.RemoveAt(num);
					RefreshAreaMarkerVisuals(val);
				}
			}
		}

		private static void EnsureAreaMarkerBrightnessTracked(PrivateArea area)
		{
			if (!ActiveAreaMarkerBrightnessAreas.Contains(area))
			{
				ActiveAreaMarkerBrightnessAreas.Add(area);
			}
		}

		private static void ResetBoundaryTrackingState()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			_hasBoundaryFlashPlayerPosition = false;
			_boundaryFlashPlayerInstanceId = 0;
			_boundaryFlashPlayerPosition = default(Vector3);
			BoundaryFlashPreviousCandidates.Clear();
			BoundaryFlashCurrentCandidates.Clear();
			BoundaryFlashCandidateIds.Clear();
		}

		private static void RefreshAreaMarkerVisuals(PrivateArea area)
		{
			InvalidateAreaMarkerVisuals(area);
			ApplyAreaState(ManagedWardRef.FromArea(area));
		}

		private static bool IsAreaMarkerBrightnessActive(PrivateArea area)
		{
			if (ManagedWardRuntimeContexts.TryGet(area, out ManagedWardRuntimeContext context))
			{
				return IsAreaMarkerBrightnessActive(area, context, Time.unscaledTime);
			}
			return false;
		}

		private static bool IsAreaMarkerBrightnessActive(PrivateArea area, ManagedWardRuntimeContext context, float now)
		{
			if (!area.IsEnabled() || !(now < context.AreaMarkerBoundaryFlashUntil))
			{
				return now < context.AreaMarkerPlacementHighlightUntil;
			}
			return true;
		}

		private static bool IsPlacementBlockerHighlightActive(PrivateArea area)
		{
			if (ManagedWardRuntimeContexts.TryGet(area, out ManagedWardRuntimeContext context))
			{
				return Time.unscaledTime < context.AreaMarkerPlacementHighlightUntil;
			}
			return false;
		}

		private static Plugin.BoundaryBrightenMode GetBoundaryBrightenMode()
		{
			return Plugin.WardBoundaryBrightenMode?.Value ?? Plugin.BoundaryBrightenMode.All;
		}

		private static bool IsBoundaryBrightenModeEnabled(Plugin.BoundaryBrightenMode mode)
		{
			if ((uint)(mode - 1) <= 2u)
			{
				return true;
			}
			return false;
		}

		private static bool ShouldBrightenBoundary(PrivateArea area, long playerId, Plugin.BoundaryBrightenMode mode)
		{
			if (playerId == 0L)
			{
				return false;
			}
			return mode switch
			{
				Plugin.BoundaryBrightenMode.All => true, 
				Plugin.BoundaryBrightenMode.TrustedOnly => WardAccess.HasManagedWardTrust(area, playerId), 
				Plugin.BoundaryBrightenMode.UntrustedOnly => !WardAccess.HasManagedWardTrust(area, playerId), 
				_ => false, 
			};
		}

		internal static float GetRadius(PrivateArea area)
		{
			return GetConfiguration(area).Radius;
		}

		internal static float GetStoredRadiusOrMin(PrivateArea area)
		{
			if (!((Object)(object)area == (Object)null))
			{
				return GetStoredRadius(GetZdo(area));
			}
			return 8f;
		}

		internal static float GetStoredRadius(ZDO? zdo, float defaultRadius = 8f)
		{
			float num = ((zdo != null) ? zdo.GetFloat("stuw_radius", defaultRadius) : defaultRadius);
			if (float.IsNaN(num) || float.IsInfinity(num))
			{
				num = defaultRadius;
			}
			return Mathf.Clamp(num, 8f, MaxRadius);
		}

		internal static bool TryAssignAuthoritativePlacementRadius(ZDO? zdo, out float radius)
		{
			radius = 8f;
			if (zdo == null || !zdo.IsValid() || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || zdo.GetOwner() != ZDOMan.GetSessionID())
			{
				return false;
			}
			float maxNonOverlappingRadius = GetMaxNonOverlappingRadius(zdo);
			if (float.IsNaN(maxNonOverlappingRadius) || float.IsInfinity(maxNonOverlappingRadius) || maxNonOverlappingRadius < 8f)
			{
				radius = maxNonOverlappingRadius;
				return false;
			}
			radius = Mathf.Clamp(maxNonOverlappingRadius, 8f, MaxRadius);
			zdo.Set("stuw_radius", radius);
			return true;
		}

		internal static bool IsDoorAutoCloseEnabledAt(Vector3 point)
		{
			//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)
			foreach (PrivateArea candidateManagedWard in WardAccess.GetCandidateManagedWards(point, 0f, requireEnabled: true))
			{
				if (!((Object)(object)candidateManagedWard == (Object)null) && candidateManagedWard.IsInside(point, 0f) && GetConfiguration(candidateManagedWard).AutoCloseEnabled)
				{
					return true;
				}
			}
			return false;
		}

		internal static bool HandleManagedFlashEffect(PrivateArea area)
		{
			if (!WardAccess.IsManagedWard(area, requireEnabled: false) || area.m_flashEffect == null)
			{
				return true;
			}
			WardConfiguration configuration = GetConfiguration(area);
			if (!configuration.WarningFlashEnabled && !configuration.WarningSoundEnabled)
			{
				return false;
			}
			ManagedWardRuntimeContext orCreate = ManagedWardRuntimeContexts.GetOrCreate(area);
			float unscaledTime = Time.unscaledTime;
			if (unscaledTime < orCreate.WarningEffectCooldownUntil)
			{
				return false;
			}
			orCreate.WarningEffectCooldownUntil = unscaledTime + 0.5f;
			if (configuration.WarningFlashEnabled && configuration.WarningSoundEnabled)
			{
				return true;
			}
			PlayManagedWarningEffect(area, configuration.WarningSoundEnabled, configuration.WarningFlashEnabled);
			return false;
		}

		private static void PlayManagedWarningEffect(PrivateArea area, bool warningSoundEnabled, bool warningFlashEnabled)
		{
			//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)
			if (!warningFlashEnabled && !warningSoundEnabled)
			{
				return;
			}
			GameObject[] array = area.m_flashEffect.Create(((Component)area).transform.position, Quaternion.identity, (Transform)null, 1f, -1);
			if (array == null)
			{
				return;
			}
			foreach (GameObject val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				if (!warningSoundEnabled)
				{
					AudioSource[] componentsInChildren = val.GetComponentsInChildren<AudioSource>(true);
					foreach (AudioSource val2 in componentsInChildren)
					{
						if (!((Object)(object)val2 == (Object)null))
						{
							val2.mute = true;
							val2.volume = 0f;
							if (val2.isPlaying)
							{
								val2.Stop();
							}
						}
					}
				}
				if (warningFlashEnabled)
				{
					continue;
				}
				Renderer[] componentsInChildren2 = val.GetComponentsInChildren<Renderer>(true);
				foreach (Renderer val3 in componentsInChildren2)
				{
					if ((Object)(object)val3 != (Object)null)
					{
						val3.enabled = false;
					}
				}
				Light[] componentsInChildren3 = val.GetComponentsInChildren<Light>(true);
				foreach (Light val4 in componentsInChildren3)
				{
					if ((Object)(object)val4 != (Object)null)
					{
						((Behaviour)val4).enabled = false;
					}
				}
			}
		}

		internal static WardConfiguration WithWarningSoundEnabled(WardConfiguration configuration, bool enabled)
		{
			bool? warningSoundEnabled = enabled;
			return CopyConfiguration(configuration, null, null, null, warningSoundEnabled);
		}

		internal static WardConfiguration WithWarningFlashEnabled(WardConfiguration configuration, bool enabled)
		{
			bool? warningFlashEnabled = enabled;
			return CopyConfiguration(configuration, null, null, null, null, warningFlashEnabled);
		}

		internal static WardConfigurationRequestSubmission RequestUpdateConfiguration(PrivateArea area, WardConfiguration configuration)
		{
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			ZNetView nView = GetNView(area);
			Player localPlayer = Player.m_localPlayer;
			WardConfiguration configuration2 = GetConfiguration(area);
			if ((Object)(object)nView == (Object)null || (Object)(object)localPlayer == (Object)null || !nView.IsValid())
			{
				return new WardConfigurationRequestSubmission(isPending: false, 0L, WardConfigurationRequestResultCode.InvalidState, configuration2);
			}
			if (WardOwnership.CanApplyManagedWardStateLocally(nView))
			{
				if (!WardAccess.HasManagedWardTrust(area, localPlayer.GetPlayerID()))
				{
					return new WardConfigurationRequestSubmission(isPending: false, 0L, WardConfigurationRequestResultCode.Denied, configuration2);
				}
				ZDO zDO = nView.GetZDO();
				if (!WardOwnership.TryClaimManagedWardMutationOwnership(zDO))
				{
					return new WardConfigurationRequestSubmission(isPending: false, 0L, WardConfigurationRequestResultCode.InvalidState, configuration2);
				}
				WardConfigurationUpdateResult wardConfigurationUpdateResult = ProcessConfigurationUpdate(zDO, configuration, configuration2);
				return new WardConfigurationRequestSubmission(isPending: false, 0L, wardConfigurationUpdateResult.ResultCode, wardConfigurationUpdateResult.Configuration);
			}
			long num = AllocateConfigurationRequestId();
			ZPackage val = new ZPackage();
			val.Write(nView.GetZDO().m_uid);
			val.Write(num);
			WriteConfigurationPayload(val, configuration);
			if (!WardOwnership.TryInvokeServerRoutedRpc("STUWard_UpdateSettings", val))
			{
				return new WardConfigurationRequestSubmission(isPending: false, 0L, WardConfigurationRequestResultCode.InvalidState, configuration2);
			}
			return new WardConfigurationRequestSubmission(isPending: true, num, WardConfigurationRequestResultCode.Applied, configuration2);
		}

		internal static void RequestRemovePermitted(PrivateArea area, long targetPlayerId)
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			ZNetView nView = GetNView(area);
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)nView == (Object)null || (Object)(object)localPlayer == (Object)null || !nView.IsValid())
			{
				return;
			}
			if (WardOwnership.CanApplyManagedWardStateLocally(nView))
			{
				if (WardAccess.HasManagedWardTrust(area, localPlayer.GetPlayerID()))
				{
					ZDO zDO = nView.GetZDO();
					if (WardOwnership.TryClaimManagedWardMutationOwnership(zDO) && WardPrivateAreaSafeAccess.RemovePermittedPlayer(zDO, targetPlayerId))
					{
						WardOwnership.CompleteAuthoritativePermittedMutation(zDO);
					}
				}
			}
			else
			{
				ZPackage val = new ZPackage();
				val.Write(nView.GetZDO().m_uid);
				val.Write(targetPlayerId);
				WardOwnership.TryInvokeServerRoutedRpc("STUWard_RemovePermitted", val);
			}
		}

		private static void HandleRoutedUpdateConfiguration(long sender, ZPackage? pkg)
		{
			//IL_0030: 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_006f: 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_0097: 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_00af: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer() && TryReadWardZdoId(pkg, out var wardZdoId))
			{
				ZDOMan instance = ZDOMan.instance;
				ZDO zdo = ((instance != null) ? instance.GetZDO(wardZdoId) : null);
				WardConfiguration configuration = GetConfiguration(zdo);
				if (!TryReadConfigurationRequest(pkg, out var requestId, out var configuration2))
				{
					SendRoutedUpdateConfigurationResponse(sender, wardZdoId, 0L, new WardConfigurationUpdateResult(WardConfigurationRequestResultCode.InvalidPayload, configuration));
					return;
				}
				if (zdo == null || !zdo.IsValid() || !WardOwnership.IsManagedWardZdo(zdo))
				{
					SendRoutedUpdateConfigurationResponse(sender, wardZdoId, requestId, new WardConfigurationUpdateResult(WardConfigurationRequestResultCode.InvalidState, configuration2));
					return;
				}
				if (!WardOwnership.TryResolveAuthoritativeManagedWardRequest(sender, wardZdoId, out zdo, out long requesterId) || !WardAccess.HasManagedWardTrust(zdo, requesterId))
				{
					SendRoutedUpdateConfigurationResponse(sender, wardZdoId, requestId, new WardConfigurationUpdateResult(WardConfigurationRequestResultCode.Denied, configuration));
					return;
				}
				if (!WardOwnership.TryClaimManagedWardMutationOwnership(zdo))
				{
					SendRoutedUpdateConfigurationResponse(sender, wardZdoId, requestId, new WardConfigurationUpdateResult(WardConfigurationRequestResultCode.InvalidState, configuration));
					return;
				}
				WardConfigurationUpdateResult result = ProcessConfigurationUpdate(zdo, configuration2, configuration);
				SendRoutedUpdateConfigurationResponse(sender, wardZdoId, requestId, result);
			}
		}

		private static void HandleRoutedUpdateConfigurationResponse(long sender, ZPackage? pkg)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if (WardOwnership.IsAuthoritativeServerSender(sender) && TryReadWardZdoId(pkg, out var wardZdoId))
			{
				ZNetScene instance = ZNetScene.instance;
				GameObject val = ((instance != null) ? instance.FindInstance(wardZdoId) : null);
				PrivateArea val2 = (((Object)(object)val != (Object)null) ? (val.GetComponent<PrivateArea>() ?? val.GetComponentInChildren<PrivateArea>()) : null);
				if ((Object)(object)val2 != (Object)null)
				{
					HandleUpdateConfigurationResponse(val2, sender, pkg);
				}
			}
		}

		private static void HandleRoutedRemovePermitted(long sender, ZPackage? pkg)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer() && TryReadWardZdoId(pkg, out var wardZdoId) && TryReadRemovePermittedRequest(pkg, out var targetPlayerId) && WardOwnership.TryResolveAuthoritativeManagedWardRequest(sender, wardZdoId, out ZDO zdo, out long requesterId) && WardAccess.HasManagedWardTrust(zdo, requesterId) && WardOwnership.TryClaimManagedWardMutationOwnership(zdo) && WardPrivateAreaSafeAccess.RemovePermittedPlayer(zdo, targetPlayerId))
			{
				WardOwnership.CompleteAuthoritativePermittedMutation(zdo);
			}
		}

		private static void HandleUpdateConfigurationResponse(PrivateArea area, long sender, ZPackage pkg)
		{
			if (WardOwnership.IsAuthoritativeServerSender(sender) && TryReadConfigurationResponse(area, pkg, out var requestId, out var resultCode, out var configuration))
			{
				ShowConfigurationRequestFeedback(resultCode);
				WardGuiController.Instance?.HandleWardConfigurationResponse(area, requestId, resultCode, configuration);
			}
		}

		private static bool TryCreateConfiguration(float radius, bool areaMarkerRotationEnabled, bool autoCloseEnabled, bool warningSoundEnabled, bool warningFlashEnabled, WardRestrictionOptions restrictions, out WardConfiguration configuration)
		{
			configuration = default(WardConfiguration);
			if (float.IsNaN(radius) || float.IsInfinity(radius))
			{
				return false;
			}
			configuration = new WardConfiguration(Mathf.Clamp(radius, 8f, MaxRadius), areaMarkerRotationEnabled, autoCloseEnabled, warningSoundEnabled, warningFlashEnabled, NormalizeRestrictions(restrictions));
			return true;
		}

		private static void WriteConfigurationPayload(ZPackage pkg, WardConfiguration configuration)
		{
			pkg.Write(configuration.Radius);
			pkg.Write(configuration.AreaMarkerRotationEnabled);
			pkg.Write(configuration.AutoCloseEnabled);
			pkg.Write(configuration.WarningSoundEnabled);
			pkg.Write(configuration.WarningFlashEnabled);
			pkg.Write((int)configuration.Restrictions);
		}

		private static void SaveConfiguration(ZDO zdo, WardConfiguration currentConfiguration, WardConfiguration configuration)
		{
			if (!Mathf.Approximately(currentConfiguration.Radius, configuration.Radius))
			{
				zdo.Set("stuw_radius", configuration.Radius);
			}
			if (currentConfiguration.AreaMarkerRotationEnabled != configuration.AreaMarkerRotationEnabled)
			{
				zdo.Set("stuw_area_marker_rotation_enabled", configuration.AreaMarkerRotationEnabled);
			}
			if (currentConfiguration.AutoCloseEnabled != configuration.AutoCloseEnabled)
			{
				zdo.Set("stuw_auto_close_enabled", configuration.AutoCloseEnabled);
			}
			if (currentConfiguration.WarningSoundEnabled != configuration.WarningSoundEnabled)
			{
				zdo.Set("stuw_warning_sound_enabled", configuration.WarningSoundEnabled);
			}
			if (currentConfiguration.WarningFlashEnabled != configuration.WarningFlashEnabled)
			{
				zdo.Set("stuw_warning_flash_enabled", configuration.WarningFlashEnabled);
			}
			if (currentConfiguration.Restrictions != configuration.Restrictions)
			{
				zdo.Set("stuw_restriction_options", (int)configuration.Restrictions);
			}
		}

		private static WardConfigurationUpdateResult ProcessConfigurationUpdate(ZDO zdo, WardConfiguration requestedConfiguration, WardConfiguration currentConfiguration)
		{
			WardConfiguration wardConfiguration = ClampConfiguration(zdo, requestedConfiguration);
			if (ConfigurationsMatch(currentConfiguration, wardConfiguration))
			{
				return new WardConfigurationUpdateResult(WardConfigurationRequestResultCode.Unchanged, currentConfiguration);
			}
			SaveConfiguration(zdo, currentConfiguration, wardConfiguration);
			WardOwnership.CompleteAuthoritativeManagedWardMutation(zdo);
			return new WardConfigurationUpdateResult(WardConfigurationRequestResultCode.Applied, wardConfiguration);
		}

		private static WardConfiguration ClampConfiguration(ZDO zdo, WardConfiguration configuration)
		{
			float maxNonOverlappingRadius = GetMaxNonOverlappingRadius(zdo);
			float value = Mathf.Clamp(Mathf.Min(GetStoredRadius(zdo), maxNonOverlappingRadius), 8f, MaxRadius);
			WardConfiguration configuration2 = configuration;
			float? radius = value;
			WardRestrictionOptions? restrictions = ApplyForcedRestrictions(configuration.Restrictions);
			return CopyConfiguration(configuration2, radius, null, null, null, null, restrictions);
		}

		private static float GetMaxNonOverlappingRadius(ZDO zdo)
		{
			//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_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: 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_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_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)
			ZDOMan instance = ZDOMan.instance;
			if (instance == null)
			{
				return MaxRadius;
			}
			Vector3 position = zdo.GetPosition();
			long ownerPlayerId = zdo.GetLong(ZDOVars.s_creator, 0L);
			bool flag = GuildsCompat.IsAvailable();
			int num = (flag ? GuildsCompat.GetWardGuildId(zdo) : 0);
			List<WardOverlapArea> list = new List<WardOverlapArea>();
			foreach (ZDO value in instance.m_objectsByID.Values)
			{
				if (value != null && !(value.m_uid == zdo.m_uid) && WardOwnership.IsManagedWardZdo(value) && WardOwnership.IsAcceptedManagedWard(value))
				{
					Vector3 position2 = value.GetPosition();
					list.Add(new WardOverlapArea(((object)Unsafe.As<ZDOID, ZDOID>(ref value.m_uid)/*cast due to .constrained prefix*/).GetHashCode(), position2.x, position2.z, GetStoredRadius(value), value.GetLong(ZDOVars.s_creator, 0L), (num != 0 && flag) ? GuildsCompat.GetWardGuildId(value) : 0));
				}
			}
			return WardOverlapPolicy.GetMaxNonOverlappingRadius(MaxRadius, new WardOverlapQuery(position.x, position.z, MaxRadius, ownerPlayerId, num), list);
		}

		private static void ApplyAreaMarkerVisuals(PrivateArea area, CircleProjector marker, WardConfiguration configuration)
		{
			//IL_0033: 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_0038: 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_0093: Unknown result type (might be due to invalid IL or missing references)
			List<GameObject> segments = marker.m_segments;
			if (segments == null || segments.Count == 0)
			{
				return;
			}
			Vector3 baseScale = (((Object)(object)marker.m_prefab != (Object)null) ? marker.m_prefab.transform.localScale : Vector3.one);
			float lengthScale = Mathf.Clamp(configuration.Radius / MaxRadius * 2f, 0f, 2f);
			float brightness = (IsAreaMarkerBrightnessActive(area) ? 1f : 0.35f);
			for (int i = 0; i < segments.Count; i++)
			{
				GameObject val = segments[i];
				if (!((Object)(object)val == (Object)null))
				{
					val.transform.localScale = ScaleMarkerSegment(baseScale, lengthScale);
					ApplyAreaMarkerBrightness(val, brightness);
				}
			}
		}

		private static Vector3 ScaleMarkerSegment(Vector3 baseScale, float lengthScale)
		{
			//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: 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_003c: 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_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_0022: Unknown result type (might be due to invalid IL or missing references)
			if (baseScale.x > baseScale.z)
			{
				return new Vector3(baseScale.x * lengthScale, baseScale.y, baseScale.z);
			}
			return new Vector3(baseScale.x, baseScale.y, baseScale.z * lengthScale);
		}

		private static void ApplyAreaMarkerBrightness(GameObject segment, float brightness)
		{
			//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)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			Renderer[] componentsInChildren = segment.GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Material sharedMaterial = val.sharedMaterial;
				if ((Object)(object)sharedMaterial == (Object)null)
				{
					continue;
				}
				AreaMarkerPropertyBlock.Clear();
				val.GetPropertyBlock(AreaMarkerPropertyBlock);
				bool flag = false;
				for (int j = 0; j < AreaMarkerColorProperties.Length; j++)
				{
					string text = AreaMarkerColorProperties[j];
					if (sharedMaterial.HasProperty(text))
					{
						Color color = sharedMaterial.GetColor(text);
						color.r *= brightness;
						color.g *= brightness;
						color.b *= brightness;
						AreaMarkerPropertyBlock.SetColor(text, color);
						flag = true;
					}
				}
				if (flag)
				{
					val.SetPropertyBlock(AreaMarkerPropertyBlock);
				}
			}
		}

		private static void ApplyManagedAreaMarkerVisibility(PrivateArea area, bool visible)
		{
			if (visible)
			{
				((MonoBehaviour)area).CancelInvoke("HideMarker");
			}
			GameObject gameObject = ((Component)area.m_areaMarker).gameObject;
			if (gameObject.activeSelf != visible)
			{
				gameObject.SetActive(visible);
			}
		}

		private static bool ShouldRefreshAreaMarkerVisuals(PrivateArea area, CircleProjector marker, WardConfiguration configuration)
		{
			if (!TryBuildAreaMarkerVisualState(marker, configuration, out var visualState))
			{
				ManagedWardRuntimeContexts.ClearAreaMarkerVisualState(area);
				return false;
			}
			ManagedWardRuntimeContext orCreate = ManagedWardRuntimeContexts.GetOrCreate(area);
			if (orCreate.HasAreaMarkerVisualState)
			{
				return !AreaMarkerVisualStatesMatch(orCreate.AreaMarkerVisualState, visualState);
			}
			return true;
		}

		private static void CacheAreaMarkerVisualState(PrivateArea area, CircleProjector marker, WardConfiguration configuration)
		{
			if (!TryBuildAreaMarkerVisualState(marker, configuration, out var visualState))
			{
				ManagedWardRuntimeContexts.ClearAreaMarkerVisualState(area);
				return;
			}
			ManagedWardRuntimeContext orCreate = ManagedWardRuntimeContexts.GetOrCreate(area);
			orCreate.AreaMarkerVisualState = visualState;
			orCreate.HasAreaMarkerVisualState = true;
		}

		private static bool TryBuildAreaMarkerVisualState(CircleProjector marker, WardConfiguration configuration, out CachedAreaMarkerVisualState visualState)
		{
			visualState = default(CachedAreaMarkerVisualState);
			List<GameObject> segments = marker.m_segments;
			if (segments == null || segments.Count == 0)
			{
				return false;
			}
			GameObject val = segments[0];
			GameObject val2 = segments[segments.Count - 1];
			visualState = new CachedAreaMarkerVisualState(((Object)marker).GetInstanceID(), segments.Count, ((Object)(object)val != (Object)null) ? ((Object)val).GetInstanceID() : 0, ((Object)(object)val2 != (Object)null) ? ((Object)val2).GetInstanceID() : 0, MaxRadius, configuration.Radius);
			return true;
		}

		private static bool AreaMarkerVisualStatesMatch(CachedAreaMarkerVisualState left, CachedAreaMarkerVisualState right)
		{
			if (left.MarkerInstanceId == right.MarkerInstanceId && left.SegmentCount == right.SegmentCount && left.FirstSegmentInstanceId == right.FirstSegmentInstanceId && left.LastSegmentInstanceId == right.LastSegmentInstanceId && Mathf.Approximately(left.MaxRadius, right.MaxRadius))
			{
				return Mathf.Approximately(left.Radius, right.Radius);
			}
			return false;
		}

		private static long AllocateConfigurationRequestId()
		{
			if (_nextConfigurationRequestId == long.MaxValue)
			{
				_nextConfigurationRequestId = 1L;
			}
			return _nextConfigurationRequestId++;
		}

		private static bool TryReadConfigurationRequest(ZPackage? pkg, out long requestId, out WardConfiguration configuration)
		{
			requestId = 0L;
			configuration = default(WardConfiguration);
			if (pkg == null)
			{
				return false;
			}
			try
			{
				requestId = pkg.ReadLong();
				return requestId != 0L && TryReadConfigurationPayload(pkg, out configuration);
			}
			catch
			{
				requestId = 0L;
				configuration = default(WardConfiguration);
				return false;
			}
		}

		private static bool TryReadWardZdoId(ZPackage? pkg, out ZDOID wardZdoId)
		{
			//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_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_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)
			wardZdoId = ZDOID.None;
			if (pkg == null)
			{
				return false;
			}
			try
			{
				wardZdoId = pkg.ReadZDOID();
				return !((ZDOID)(ref wardZdoId)).IsNone();
			}
			catch
			{
				wardZdoId = ZDOID.None;
				return false;
			}
		}

		private static bool TryReadRemovePermittedRequest(ZPackage? pkg, out long targetPlayerId)
		{
			targetPlayerId = 0L;
			if (pkg == null)
			{
				return false;
			}
			try
			{
				targetPlayerId = pkg.ReadLong();
				return targetPlayerId != 0;
			}
			catch
			{
				targetPlayerId = 0L;
				return false;
			}
		}

		private static void SendRoutedUpdateConfigurationResponse(long receiverUid, ZDOID wardZdoId, long requestId, WardConfigurationUpdateResult result)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (receiverUid != 0L && !((ZDOID)(ref wardZdoId)).IsNone())
			{
				ZPackage val = new ZPackage();
				val.Write(wardZdoId);
				val.Write(requestId);
				val.Write((int)result.ResultCode);
				WriteConfigurationPayload(val, result.Configuration);
				ZRoutedRpc instance = ZRoutedRpc.instance;
				if (instance != null)
				{
					instance.InvokeRoutedRPC(receiverUid, "STUWard_UpdateSettingsResponse", new object[1] { val });
				}
			}
		}

		private static bool TryReadConfigurationResponse(PrivateArea area, ZPackage? pkg, out long requestId, out WardConfigurationRequestResultCode resultCode, out WardConfiguration configuration)
		{
			requestId = 0L;
			resultCode = WardConfigurationRequestResultCode.InvalidState;
			configuration = GetConfiguration(area);
			if (pkg == null)
			{
				return false;
			}
			try
			{
				requestId = pkg.ReadLong();
				resultCode = (WardConfigurationRequestResultCode)pkg.ReadInt();
				return TryReadConfigurationPayload(pkg, out configuration);
			}
			catch
			{
				requestId = 0L;
				resultCode = WardConfigurationRequestResultCode.InvalidState;
				configuration = GetConfiguration(area);
				return false;
			}
		}

		private static bool TryReadConfigurationPayload(ZPackage pkg, out WardConfiguration configuration)
		{
			configuration = default(WardConfiguration);
			if (pkg == null)
			{
				return false;
			}
			try
			{
				float radius = pkg.ReadSingle();
				bool areaMarkerRotationEnabled = pkg.ReadBool();
				bool autoCloseEnabled = pkg.ReadBool();
				bool warningSoundEnabled = pkg.ReadBool();
				bool warningFlashEnabled = pkg.ReadBool();
				WardRestrictionOptions restrictions = (WardRestrictionOptions)pkg.ReadInt();
				return TryCreateConfiguration(radius, areaMarkerRotationEnabled, autoCloseEnabled, warningSoundEnabled, warningFlashEnabled, restrictions, out configuration);
			}
			catch
			{
				configuration = default(WardConfiguration);
				return false;
			}
		}

		internal static void ShowConfigurationRequestFeedback(WardConfigurationRequestResultCode resultCode)
		{
			Player localPlayer = Player.m_localPlayer;
			if (resultCode == WardConfigurationRequestResultCode.Denied)
			{
				WardAccess.ShowNoAccessMessage(localPlayer);
			}
		}

		internal static bool ConfigurationsMatch(WardConfiguration left, WardConfiguration right)
		{
			if (Mathf.Approximately(left.Radius, right.Radius) && left.AreaMarkerRotationEnabled == right.AreaMarkerRotationEnabled && left.AutoCloseEnabled == right.AutoCloseEnabled && left.WarningSoundEnabled == right.WarningSoundEnabled && left.WarningFlashEnabled == right.WarningFlashEnabled)
			{
				return left.Restrictions == right.Restrictions;
			}
			return false;
		}

		private static WardRestrictionOptions ApplyForcedRestrictions(WardRestrictionOptions restrictions)
		{
			return ApplyForcedRestrictions(restrictions, ForcedRestrictions);
		}

		private static WardRestrictionOptions ApplyForcedRestrictions(WardRestrictionOptions restrictions, WardRestrictionOptions forcedRestrictions)
		{
			return NormalizeRestrictions(restrictions) | forcedRestrictions;
		}

		private static WardRestrictionOptions NormalizeRestrictions(WardRestrictionOptions restrictions)
		{
			return restrictions & WardRestrictionOptions.All;
		}

		private static ZNetView? GetNView(PrivateArea area)
		{
			return WardPrivateAreaSafeAccess.GetNView(area);
		}

		private static ZDO? GetZdo(PrivateArea area)
		{
			return WardPrivateAreaSafeAccess.GetZdo(area);
		}
	}
	internal static class WardLocalization
	{
		internal const string PieceNameToken = "$stuw_piece_name";

		internal const string PieceDescriptionToken = "$stuw_piece_desc";

		internal const string UiTitleToken = "$stuw_ui_title";

		internal const string UiOwnerToken = "$stuw_ui_owner";

		internal const string UiGuildToken = "$stuw_ui_guild";

		internal const string UiCloseToken = "$stuw_ui_close";

		internal const string UiAutoCloseToken = "$stuw_ui_auto_close";

		internal const string UiWarningSoundToken = "$stuw_ui_warning_sound";

		internal const string UiWarningFlashToken = "$stuw_ui_warning_flash";

		internal const string UiAreaMarkerRotationToken = "$stuw_ui_area_marker_rotation";

		internal const string UiRegisteredPlayersToken = "$stuw_ui_registered_players";

		internal const string UiUnregisteredPlayersToken = "$stuw_ui_unregistered_players";

		internal const string UiRestrictionsToken = "$stuw_ui_restrictions";

		internal const string UiRestrictionForcedToken = "$stuw_ui_restriction_forced";

		internal const string UiRestrictionDoorsToken = "$stuw_ui_restriction_doors";

		internal const string UiRestrictionPortalsToken = "$stuw_ui_restriction_portals";

		internal const string UiRestrictionPickupToken = "$stuw_ui_restriction_pickup";

		internal const string UiRestrictionPlacedConsumablesToken = "$stuw_ui_restriction_placed_consumables";

		internal const string UiRestrictionItemStandsToken = "$stuw_ui_restriction_item_stands";

		internal const string UiRestrictionArmorStandsToken = "$stuw_ui_restriction_armor_stands";

		internal const string UiRestrictionContainersToken = "$stuw_ui_restriction_containers";

		internal const string UiRestrictionCraftingStationsToken = "$stuw_ui_restriction_crafting_stations";

		internal const string UiRestrictionTameablesAndSaddlesToken = "$stuw_ui_restriction_tameables_and_saddles";

		internal const string UiNoRegisteredPlayersToken = "$stuw_ui_no_registered_players";

		internal const string UiNoUnregisteredPlayersToken = "$stuw_ui_no_unregistered_players";

		internal const string UiRecentPlayersLoadingToken = "$stuw_ui_recent_players_loading";

		internal const string UiRecentPlayersErrorToken = "$stuw_ui_recent_players_error";

		internal const string UiSearchPlayersToken = "$stuw_ui_search_players";

		internal const string UiNoMatchingPlayersToken = "$stuw_ui_no_matching_players";

		internal const string UiRemoveToken = "$stuw_ui_remove";

		internal const string UiAddToken = "$stuw_ui_add";

		internal const string UiOnlineToken = "$stuw_ui_online";

		internal const string UiLastSeenUnavailableToken = "$stuw_ui_last_seen_unavailable";

		internal const string UiLastSeenJustNowToken = "$stuw_ui_last_seen_just_now";

		internal const string UiLastSeenMinutesAgoToken = "$stuw_ui_last_seen_minutes_ago";

		internal const string UiLastSeenHoursAgoToken = "$stuw_ui_last_seen_hours_ago";

		internal const string UiLastSeenDaysAgoToken = "$stuw_ui_last_seen_days_ago";

		internal const string UiRegisteredPlayerFormatToken = "$stuw_ui_registered_player_format";

		internal const string HoverSettingsToken = "$stuw_hover_settings";

		internal const string MessageBlockedItemToken = "$stuw_msg_blocked_item";

		internal const string MessageBuildingDamageProtectedToken = "$stuw_msg_building_damage_protected";

		internal const string MessageOverlapToken = "$stuw_msg_overlap";

		internal const string MessageLimitWithMaxToken = "$stuw_msg_limit_with_max";

		internal const string ShortcutUnboundToken = "$stuw_shortcut_unbound";

		internal const string PieceNameFallback = "Ward";

		internal const string PieceDescriptionFallback = "Configurable ward with extended protection.";

		internal const string UiTitleFallback = "Ward Settings";

		internal const string UiOwnerFallback = "Owner: {0}";

		internal const string UiGuildFallback = "Guild: {0}";

		internal const string UiCloseFallback = "Close";

		internal const string UiAutoCloseFallback = "Door auto-close";

		internal const string UiWarningSoundFallback = "Ward alert sound";

		internal const string UiWarningFlashFallback = "Ward alert visual effect";

		internal const string UiAreaMarkerRotationFallback = "Ward range rotation";

		internal const string UiRegisteredPlayersFallback = "Individually trusted players";

		internal const string UiUnregisteredPlayersFallback = "Unregistered players";

		internal const string UiRestrictionsFallback = "Restrictions";

		internal const string UiRestrictionForcedFallback = "Forced";

		internal const string UiRestrictionDoorsFallback = "Doors";

		internal const string UiRestrictionPortalsFallback = "Portals";

		internal const string UiRestrictionPickupFallback = "Pickup";

		internal const string UiRestrictionPlacedConsumablesFallback = "Consumables";

		internal const string UiRestrictionItemStandsFallback = "Item stands";

		internal const string UiRestrictionArmorStandsFallback = "Armor stands";

		internal const string UiRestrictionContainersFallback = "Containers";

		internal const string UiRestrictionCraftingStationsFallback = "Crafting stations";

		internal const string UiRestrictionTameablesAndSaddlesFallback = "Tames";

		internal const string UiNoRegisteredPlayersFallback = "No individually trusted players.";

		internal const string UiNoUnregisteredPlayersFallback = "No unregistered players seen in the last 14 days.";

		internal const string UiRecentPlayersLoadingFallback = "Loading recent players...";

		internal const string UiRecentPlayersErrorFallback = "Could not load recent players.";

		internal const string UiSearchPlayersFallback = "Search players...";

		internal const string UiNoMatchingPlayersFallback = "No matching players.";

		internal const string UiRemoveFallback = "Remove";

		internal const string UiAddFallback = "Add";

		internal const string UiOnlineFallback = "Online";

		internal const string UiLastSeenUnavailableFallback = "Last seen unavailable";

		internal const string UiLastSeenJustNowFallback = "Seen just now";

		internal const string UiLastSeenMinutesAgoFallback = "Seen {0}m ago";

		internal const string UiLastSeenHoursAgoFallback = "Seen {0}h ago";

		internal const string UiLastSeenDaysAgoFallback = "Seen {0}d ago";

		internal const string UiRegisteredPlayerFormatFallback = "{0} / {1} / {2}";

		internal const string HoverSettingsFallback = "[<color=yellow><b>{0}</b></color>] Ward settings";

		internal const string MessageBlockedItemFallback = "A ward prevents using this item here.";

		internal const string MessageBuildingDamageProtectedFallback = "An active Ward prevents damaging protected structures.";

		internal const string MessageOverlapFallback = "Another Ward is too close.";

		internal const string MessageLimitWithMaxFallback = "Ward limit reached (max {0})";

		internal const string ShortcutUnboundFallback = "Unbound";

		internal static string Localize(string token, string fallback)
		{
			Localization instance = Localization.instance;
			if (instance == null)
			{
				return fallback;
			}
			string text = instance.Localize(token);
			string text2;
			if (!token.StartsWith("$", StringComparison.Ordinal))
			{
				text2 = "[" + token + "]";
			}
			else
			{
				text2 = "[" + token.Substring(1, token.Length - 1) + "]";
			}
			string text3 = text2;
			if (!string.IsNullOrWhiteSpace(text) && !(text == token) && !(text == text3))
			{
				return text;
			}
			return fallback;
		}

		internal static string LocalizeFormat(string token, string fallback, params object[] args)
		{
			string text = Localize(token, fallback);
			if (args != null && args.Length != 0)
			{
				return string.Format(text, args);
			}
			return text;
		}
	}
	internal static class WardItemPrefabPolicy
	{
		private static readonly CustomSyncedValue<string> ItemPrefabData = new CustomSyncedValue<string>(Plugin.ConfigSync, "itemPrefabData", string.Empty);

		private static readonly IDeserializer Deserializer = new DeserializerBuilder().WithDuplicateKeyChecking().Build();

		private static HashSet<string> _blockedItemPrefabNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private static HashSet<string> _pickupWhitelistPrefabNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private static HashSet<string> _pickupBlacklistPrefabNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private static bool _initialized;

		internal static void Initialize()
		{
			if (!_initialized)
			{
				_initialized = true;
				ItemPrefabData.ValueChanged += ApplySyncedYaml;
				ManagedWardConfigFileService.ConfigChanged += HandleManagedWardConfigChanged;
				ApplyAuthoritativeConfigFromService();
			}
		}

		internal static void Shutdown()
		{
			if (_initialized)
			{
				ItemPrefabData.ValueChanged -= ApplySyncedYaml;
				ManagedWardConfigFileService.ConfigChanged -= HandleManagedWardConfigChanged;
				_initialized = false;
			}
		}

		internal static bool IsBlockedItem(string prefabName)
		{
			prefabName = NormalizePrefabName(prefabName);
			if (!string.IsNullOrWhiteSpace(prefabName))
			{
				return _blockedItemPrefabNames.Contains(prefabName);
			}
			return false;
		}

		internal static bool IsBlockedItem(ItemData? item)
		{
			return IsBlockedItem(GetItemPrefabName(item));
		}

		internal static bool HasBlockedItems()
		{
			return _blockedItemPrefabNames.Count > 0;
		}

		internal static bool CanAnyPickupBeBlocked()
		{
			if (Plugin.PickupBlockMode.Value == Plugin.PickupBlockRule.AllowAllExceptBlacklist)
			{
				return _pickupBlacklistPrefabNames.Count > 0;
			}
			return true;
		}

		internal static bool ShouldBlockPickup(ItemDrop? itemDrop)
		{
			return ShouldBlockPickup(GetItemPrefabName(itemDrop));
		}

		internal static bool ShouldBlockPickup(GameObject? go)
		{
			return ShouldBlockPickup(GetItemPrefabName(go));
		}

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

		private static bool ShouldBlockPickup(string prefabName)
		{
			prefabName = NormalizePrefabName(prefabName);
			if (Plugin.PickupBlockMode.Value == Plugin.PickupBlockRule.AllowAllExceptBlacklist)
			{
				return !string.IsNullOrWhiteSpace(prefabName) && _pickupBlacklistPrefabNames.Contains(prefabName);
			}
			return string.IsNullOrWhiteSpace(prefabName) || !_pickupWhitelistPrefabNames.Contains(prefabName);
		}

		private static string GetItemPrefabName(ItemDrop? itemDrop)
		{
			if ((Object)(object)itemDrop == (Object)null)
			{
				return string.Empty;
			}
			string itemPrefabName = GetItemPrefabName(itemDrop.m_itemData);
			if (string.IsNullOrWhiteSpace(itemPrefabName))
			{
				return NormalizePrefabName(((Object)itemDrop).name);
			}
			return itemPrefabName;
		}

		private static string GetItemPrefabName(GameObject? go)
		{
			if ((Object)(object)go == (Object)null)
			{
				return string.Empty;
			}
			string itemPrefabName = GetItemPrefabName(go.GetComponent<ItemDrop>() ?? go.GetComponentInParent<ItemDrop>());
			if (string.IsNullOrWhiteSpace(itemPrefabName))
			{
				return NormalizePrefabName(((Object)go).name);
			}
			return itemPrefabName;
		}

		internal static string NormalizePrefabName(string prefabName)
		{
			prefabName = prefabName.Trim();
			if (prefabName.EndsWith("(Clone)", StringComparison.Ordinal))
			{
				prefabName = prefabName.Substring(0, prefabName.Length - "(Clone)".Length).Trim();
			}
			return prefabName;
		}

		private static void HandleManagedWardConfigChanged()
		{
			ApplyAuthoritativeConfigFromService();
		}

		private static void ApplyAuthoritativeConfigFromService()
		{
			if (_initialized && Plugin.ConfigSync.IsSourceOfTruth)
			{
				ItemPrefabData.AssignLocalValue(ManagedWardConfigFileService.CurrentSnapshot.ItemPrefabPolicyYaml);
			}
		}

		private static void ApplySyncedYaml()
		{
			if (TryParseYaml(ItemPrefabData.Value, out HashSet<string> blockedItemPrefabNames, out HashSet<string> pickupWhitelistPrefabNames, out HashSet<string> pickupBlacklistPrefabNames))
			{
				_blockedItemPrefabNames = blockedItemPrefabNames;
				_pickupWhitelistPrefabNames = pickupWhitelistPrefabNames;
				_pickupBlacklistPrefabNames = pickupBlacklistPrefabNames;
				Plugin.Log.LogInfo((object)$"Applied item prefab policy: blocked_item_prefabs={_blockedItemPrefabNames.Count}, pickup_whitelist={_pickupWhitelistPrefabNames.Count}, pickup_blacklist={_pickupBlacklistPrefabNames.Count}");
			}
		}

		private static bool TryParseYaml(string yaml, out HashSet<string> blockedItemPrefabNames, out HashSet<string> pickupWhitelistPrefabNames, out HashSet<string> pickupBlacklistPrefabNames)
		{
			blockedItemPrefabNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			pickupWhitelistPrefabNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			pickupBlacklistPrefabNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			if (yaml == null)
			{
				yaml = string.Empty;
			}
			try
			{
				if (Encoding.UTF8.GetByteCount(yaml) > 262144)
				{
					throw new FormatException($"The synchronized item prefab policy exceeds {262144} bytes.");
				}
				ManagedWardConfigFileService.ManagedWardItemPrefabPolicyYaml managedWardItemPrefabPolicyYaml = (string.IsNullOrWhiteSpace(yaml) ? new ManagedWardConfigFileService.ManagedWardItemPrefabPolicyYaml() : (Deserializer.Deserialize<ManagedWardConfigFileService.ManagedWardItemPrefabPolicyYaml>(yaml) ?? new ManagedWardConfigFileService.ManagedWardItemPrefabPolicyYaml()));
				ManagedWardConfigFileService.ValidateItemPrefabPolicy(managedWardItemPrefabPolicyYaml);
				AddEntries(blockedItemPrefabNames, managedWardItemPrefabPolicyYaml.BlockedItemPrefabs);
				AddEntries(pickupWhitelistPrefabNames, managedWardItemPrefabPolicyYaml.PickupWhitelist);
				AddEntries(pickupBlacklistPrefabNames, managedWardItemPrefabPolicyYaml.PickupBlacklist);
				return true;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Failed to parse item prefab policy YAML 'STUWard.yml:item_prefab_policy': " + ex.Message));
				return false;
			}
		}

		private static void AddEntries(HashSet<string> result, IEnumerable<string>? prefabNames)
		{
			if (prefabNames == null)
			{
				return;
			}
			foreach (string prefabName in prefabNames)
			{
				string text = NormalizePrefabName(prefabName);
				if (!string.IsNullOrWhiteSpace(text))
				{
					result.Add(text);
				}
			}
		}
	}
	internal static class WardPermittedSnapshots
	{
		private readonly struct BackfillRequest
		{
			internal PrivateArea? Area { get; }

			internal int InstanceId { get; }

			internal BackfillRequest(PrivateArea area)
			{
				Area = area;
				InstanceId = ((Object)area).GetInstanceID();
			}
		}

		private readonly struct SnapshotEntry
		{
			internal long PlayerId { get; }

			internal string GuildName { get; }

			internal string PlatformId { get; }

			internal SnapshotEntry(long playerId, string guildName, string platformId)
			{
				PlayerId = playerId;
				GuildName = guildName;
				PlatformId = platformId;
			}
		}

		private sealed class CachedSnapshot
		{
			internal uint Revision { get; }

			internal Dictionary<long, SnapshotEntry> Entries { get; }

			internal CachedSnapshot(uint revision, Dictionary<long, SnapshotEntry> entries)
			{
				Revision = revision;
				Entries = entries;
			}
		}

		private const int BackfillBatchSize = 4;

		private const int SnapshotFormatVersion = 1;

		private const int MaxSnapshotDataBytes = 1048576;

		private static readonly int SnapshotVersionKey = StringExtensionMethods.GetStableHashCode("stuw_perm_snapshot_version");

		private static readonly int SnapshotDataKey = StringExtensionMethods.GetStableHashCode("stuw_perm_snapshot");

		private static readonly int SnapshotRevisionKey = StringExtensionMethods.GetStableHashCode("stuw_perm_snapshot_revision");

		private static readonly Dictionary<ZDOID, CachedSnapshot> SnapshotCache = new Dictionary<ZDOID, CachedSnapshot>();

		private static readonly List<BackfillRequest> PendingBackfillRequests = new List<BackfillRequest>();

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

		internal static void Refresh(PrivateArea? area)
		{
			if (TryGetOwnedSnapshotZdo(area, out ZDO zdo, out ZNetView _))
			{
				Refresh(zdo);
			}
		}

		internal static void Refresh(ZDO? zdo)
		{
			RefreshSnapshot(zdo);
		}

		internal static void Backfill(ManagedWardRef ward)
		{
			if (!TryGetOwnedSnapshotZdo(ward, out ZDO zdo, out ZNetView _))
			{
				Remember(ward);
				return;
			}
			TryGetSnapshot(zdo, out Dictionary<long, SnapshotEntry> _);
			EnqueueBackfill(ward.Area);
		}

		internal static void Update()
		{
			if (PendingBackfillRequests.Count == 0 || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			int num = 0;
			while (num < 4 && PendingBackfillRequests.Count > 0)
			{
				int index = PendingBackfillRequests.Count - 1;
				BackfillRequest backfillRequest = PendingBackfillRequests[index];
				PendingBackfillRequests.RemoveAt(index);
				PendingBackfillAreaIds.Remove(backfillRequest.InstanceId);
				num++;
				if (!((Object)(object)backfillRequest.Area == (Object)null) && TryGetOwnedSnapshotZdo(backfillRequest.Area, out ZDO zdo, out ZNetView _))
				{
					Refresh(zdo);
				}
			}
		}

		internal static bool HasPendingRuntimeWork()
		{
			return PendingBackfillRequests.Count > 0;
		}

		internal static bool TryGet(PrivateArea? area, long playerId, out string guildName, out string platformId)
		{
			guildName = string.Empty;
			platformId = string.Empty;
			if ((Object)(object)area == (Object)null || playerId == 0L)
			{
				return false;
			}
			ZNetView nView = WardPrivateAreaSafeAccess.GetNView(area);
			if ((Object)(object)nView == (Object)null || !nView.IsValid())
			{
				return false;
			}
			if (!TryGetSnapshot(nView, out Dictionary<long, SnapshotEntry> entries))
			{
				return false;
			}
			if (!entries.TryGetValue(playerId, out var value))
			{
				return false;
			}
			guildName = value.GuildName;
			platformId = value.PlatformId;
			if (string.IsNullOrWhiteSpace(guildName))
			{
				return !string.IsNullOrWhiteSpace(platformId);
			}
			return true;
		}

		internal static int GetRevision(PrivateArea? area)
		{
			if ((Object)(object)area == (Object)null)
			{
				return 0;
			}
			ZDO? zdo = WardPrivateAreaSafeAccess.GetZdo(area);
			if (zdo == null)
			{
				return 0;
			}
			return zdo.GetInt(SnapshotRevisionKey, 0);
		}

		internal static void Remember(ManagedWardRef ward)
		{
			ZDO zdo = ward.Zdo;
			if (zdo != null && zdo.IsValid())
			{
				TryGetSnapshot(zdo, out Dictionary<long, SnapshotEntry> _);
			}
		}

		internal static void RefreshKnownSnapshotsForGuildIdentityChanges(HashSet<long>? targetPlayerIds, HashSet<string>? targetCharacterKeys, HashSet<int>? affectedGuildIds, bool fullRefresh)
		{
			//IL_007a: 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_00b8: 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 (SnapshotCache.Count == 0 || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			HashSet<string> targetAccountIds = CollectTargetAccountIds(targetCharacterKeys);
			bool flag = fullRefresh || (affectedGuildIds != null && affectedGuildIds.Count > 0);
			List<ZDOID> list = new List<ZDOID>();
			foreach (KeyValuePair<ZDOID, CachedSnapshot> item in SnapshotCache)
			{
				if (flag || ContainsTargetIdentity(item.Value.Entries, targetPlayerIds, targetAccountIds))
				{
					list.Add(item.Key);
				}
			}
			for (int i = 0; i < list.Count; i++)
			{
				ZDOID val = list[i];
				ZDOMan instance = ZDOMan.instance;
				ZDO val2 = ((instance != null) ? instance.GetZDO(val) : null);
				if (val2 == null || !WardOwnership.IsManagedWardZdo(val2))
				{
					Forget(val);
				}
				else
				{
					RefreshSnapshot(val2);
				}
			}
		}

		private static bool RefreshSnapshot(ZDO? zdo)
		{
			if (zdo == null || !zdo.IsValid() || !zdo.IsOwner() || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return false;
			}
			TryGetSnapshot(zdo, out Dictionary<long, SnapshotEntry> entries);
			return WriteSnapshot(zdo, BuildEntries(zdo, entries));
		}

		private static bool WriteSnapshot(ZDO zdo, List<SnapshotEntry> entries)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write(1);
			val.Write(entries.Count);
			for (int i = 0; i < entries.Count; i++)
			{
				SnapshotEntry snapshotEntry = entries[i];
				val.Write(snapshotEntry.PlayerId);
				val.Write(snapshotEntry.GuildName);
				val.Write(snapshotEntry.PlatformId);
			}
			byte[] array = val.GetArray();
			int num = zdo.GetInt(SnapshotVersionKey, 0);
			byte[] byteArray = zdo.GetByteArray(SnapshotDataKey, (byte[])null);
			int num2 = zdo.GetInt(SnapshotRevisionKey, 0);
			int num3;
			if (num == 1 && num2 > 0)
			{
				num3 = ((!ByteArraysEqual(byteArray, array)) ? 1 : 0);
				if (num3 == 0)
				{
					goto IL_00d6;
				}
			}
			else
			{
				num3 = 1;
			}
			zdo.Set(SnapshotVersionKey, 1, false);
			zdo.Set(SnapshotDataKey, array);
			zdo.Set(SnapshotRevisionKey, (num2 == int.MaxValue) ? 1 : (num2 + 1), false);
			goto IL_00d6;
			IL_00d6:
			CacheSnapshot(zdo, ToLookup(entries));
			return (byte)num3 != 0;
		}

		internal static void ClearCache()
		{
			SnapshotCache.Clear();
			PendingBackfillRequests.Clear();
			PendingBackfillAreaIds.Clear();
		}

		internal static void Forget(ZDOID zdoId)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (!((ZDOID)(ref zdoId)).IsNone())
			{
				SnapshotCache.Remove(zdoId);
			}
		}

		private static void EnqueueBackfill(PrivateArea area)
		{
			int instanceID = ((Object)area).GetInstanceID();
			if (PendingBackfillAreaIds.Add(instanceID))
			{
				PendingBackfillRequests.Add(new BackfillRequest(area));
			}
		}

		private static bool TryGetOwnedSnapshotZdo(PrivateArea? area, out ZDO zdo, out ZNetView nview)
		{
			return TryGetOwnedSnapshotZdo(ManagedWardRef.FromArea(area), out zdo, out nview);
		}

		private static bool TryGetOwnedSnapshotZdo(ManagedWardRef ward, out ZDO zdo, out ZNetView nview)
		{
			zdo = null;
			nview = null;
			PrivateArea area = ward.Area;
			if ((Object)(object)area == (Object)null || Player.IsPlacementGhost(((Component)area).gameObject) || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return false;
			}
			nview = ward.NView;
			if (!ward.HasValidNetworkIdentity || !ward.IsOwner)
			{
				return false;
			}
			zdo = ward.Zdo;
			return true;
		}

		private static bool TryGetSnapshot(ZNetView nview, out Dictionary<long, SnapshotEntry> entries)
		{
			return TryGetSnapshot(WardPrivateAreaSafeAccess.GetZdo(nview), out entries);
		}

		private static bool TryGetSnapshot(ZDO? zdo, out Dictionary<long, SnapshotEntry> entries)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			entries = null;
			if (zdo == null)
			{
				return false;
			}
			if (SnapshotCache.TryGetValue(zdo.m_uid, out CachedSnapshot value) && value.Revision == zdo.DataRevision)
			{
				entries = value.Entries;
				return true;
			}
			if (!TryDeserialize(zdo, out entries))
			{
				return false;
			}
			CacheSnapshot(zdo, entries);
			return true;
		}

		private static List<SnapshotEntry> BuildEntries(ZDO? zdo, IReadOnlyDictionary<long, SnapshotEntry>? previousEntries)
		{
			IReadOnlyList<long> permittedPlayerIds = WardPrivateAreaSafeAccess.GetPermittedPlayerIds(zdo);
			List<SnapshotEntry> list = new List<SnapshotEntry>(permittedPlayerIds.Count);
			for (int i = 0; i < permittedPlayerIds.Count; i++)
			{
				long num = permittedPlayerIds[i];
				if (num != 0L)
				{
					SnapshotEntry value = default(SnapshotEntry);
					previousEntries?.TryGetValue(num, out value);
					string text = WardOwnership.NormalizeAccountIdValue(WardOwnership.GetPlayerAccountId(num));
					if (string.IsNullOrWhiteSpace(text))
					{
						text = value.PlatformId;
					}
					string playerName = WardOwnership.GetPlayerName(num);
					string text2 = value.GuildName;
					if (GuildsCompat.TryResolveCachedAuthoritativeGuildIdentity(num, text, playerName, out var guild))
					{
						text2 = ((guild.Id == 0) ? string.Empty : guild.Name);
					}
					list.Add(new SnapshotEntry(num, text2 ?? string.Empty, text ?? string.Empty));
				}
			}
			return list;
		}

		private static HashSet<string>? CollectTargetAccountIds(HashSet<string>? targetCharacterKeys)
		{
			if (targetCharacterKeys == null || targetCharacterKeys.Count == 0)
			{
				return null;
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			foreach (string targetCharacterKey in targetCharacterKeys)
			{
				if (!string.IsNullOrWhiteSpace(targetCharacterKey))
				{
					int num = targetCharacterKey.IndexOf('\n');
					string text = WardOwnership.NormalizeAccountIdValue((num >= 0) ? targetCharacterKey.Substring(0, num) : targetCharacterKey);
					if (!string.IsNullOrWhiteSpace(text))
					{
						hashSet.Add(text);
					}
				}
			}
			if (hashSet.Count != 0)
			{
				return hashSet;
			}
			return null;
		}

		private static bool ContainsTargetIdentity(IReadOnlyDictionary<long, SnapshotEntry> entries, HashSet<long>? targetPlayerIds, HashSet<string>? targetAccountIds)
		{
			foreach (KeyValuePair<long, SnapshotEntry> entry in entries)
			{
				if (targetPlayerIds != null && targetPlayerIds.Contains(entry.Key))
				{
					return true;
				}
				string item = WardOwnership.NormalizeAccountIdValue(entry.Value.PlatformId);
				if (targetAccountIds != null && targetAccountIds.Contains(item))
				{
					return true;
				}
			}
			return false;
		}

		private static void CacheSnapshot(ZDO zdo, Dictionary<long, SnapshotEntry> entries)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			SnapshotCache[zdo.m_uid] = new CachedSnapshot(zdo.DataRevision, entries);
		}

		private static bool TryDeserialize(ZDO zdo, out Dictionary<long, SnapshotEntry> entries)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			entries = new Dictionary<long, SnapshotEntry>();
			try
			{
				if (zdo.GetInt(SnapshotVersionKey, 0) != 1)
				{
					return false;
				}
				byte[] byteArray = zdo.GetByteArray(SnapshotDataKey, (byte[])null);
				if (byteArray == null || byteArray.Length == 0 || byteArray.Length > 1048576)
				{
					return false;
				}
				ZPackage val = new ZPackage(byteArray);
				if (val.ReadInt() != 1)
				{
					return false;
				}
				int num = val.ReadInt();
				if (num < 0 || num > 1024)
				{
					return false;
				}
				for (int i = 0; i < num; i++)
				{
					long num2 = val.ReadLong();
					string guildName = val.ReadString();
					string platformId = val.ReadString();
					if (num2 != 0L)
					{
						entries[num2] = new SnapshotEntry(num2, guildName, platformId);
					}
				}
				return true;
			}
			catch
			{
				entries.Clear();
				return false;
			}
		}

		private static Dictionary<long, SnapshotEntry> ToLookup(List<SnapshotEntry> entries)
		{
			Dictionary<long, SnapshotEntry> dictionary = new Dictionary<long, SnapshotEntry>(entries.Count);
			for (int i = 0; i < entries.Count; i++)
			{
				SnapshotEntry value = entries[i];
				dictionary[value.PlayerId] = value;
			}
			return dictionary;
		}

		private static bool ByteArraysEqual(byte[]? left, byte[] right)
		{
			if (left == null || left.Length != right.Length)
			{
				return false;
			}
			for (int i = 0; i < right.Length; i++)
			{
				if (left[i] != right[i])
				{
					return false;
				}
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(PrivateArea), "AddPermitted")]
	internal static class PrivateAreaAddPermittedSnapshotPatch
	{
		private static void Postfix(PrivateArea __instance, long playerID)
		{
			ManagedWardRef ward = ManagedWardRef.FromArea(__instance);
			if (WardAccess.IsManagedWard(ward, requireEnabled: false))
			{
				WardPermittedSnapshots.Refresh(__instance);
				ManagedWardPresenceService.Invalidate();
				ManagedWardMapStateService.NotifyWardMutation(__instance);
				WardOwnership.ForceSyncManagedWardZdoToServer(ward);
			}
		}
	}
	[HarmonyPatch(typeof(PrivateArea), "RemovePermitted")]
	internal static class PrivateAreaRemovePermittedSnapshotPatch
	{
		private static void Postfix(PrivateArea __instance, long playerID)
		{
			ManagedWardRef ward = ManagedWardRef.FromArea(__instance);
			if (WardAccess.IsManagedWard(ward, requireEnabled: false))
			{
				WardPermittedSnapshots.Refresh(__instance);
				ManagedWardPresenceService.Invalidate();
				ManagedWardMapStateService.NotifyWardMutation(__instance);
				WardOwnership.ForceSyncManagedWardZdoToServer(ward);
			}
		}
	}
	internal static class WardPrivateAreaSafeAccess
	{
		private sealed class CachedPermittedPlayerIds
		{
			internal uint Revision { get; }

			internal long[] PlayerIds { get; }

			internal CachedPermittedPlayerIds(uint revision, long[] playerIds)
			{
				Revision = revision;
				PlayerIds = playerIds ?? Array.Empty<long>();
			}
		}

		internal const int MaxPermittedPlayers = 1024;

		private static readonly Dictionary<ZDOID, CachedPermittedPlayerIds> PermittedPlayerIdsCache = new Dictionary<ZDOID, CachedPermittedPlayerIds>();

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

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

		internal static ZNetView? GetNView(PrivateArea? area)
		{
			if ((Object)(object)area == (Object)null)
			{
				return null;
			}
			if (!((Object)(object)area.m_nview != (Object)null))
			{
				return ((Component)area).GetComponent<ZNetView>();
			}
			return area.m_nview;
		}

		internal static ZDO? GetZdo(PrivateArea? area)
		{
			return GetZdo(GetNView(area));
		}

		internal static ZDO? GetZdo(ZNetView? nview)
		{
			if ((Object)(object)nview == (Object)null || !nview.IsValid())
			{
				return null;
			}
			return nview.GetZDO();
		}

		internal static string GetCreatorName(PrivateArea? area)
		{
			return GetCreatorName(GetZdo(area));
		}

		internal static string GetCreatorName(ZDO? zdo)
		{
			if (zdo != null)
			{
				return (zdo.GetString(ZDOVars.s_creatorName, string.Empty) ?? string.Empty).Trim();
			}
			return string.Empty;
		}

		internal static List<KeyValuePair<long, string>> GetPermittedPlayers(PrivateArea? area)
		{
			return GetPermittedPlayers(GetZdo(area));
		}

		internal static List<KeyValuePair<long, string>> GetPermittedPlayers(ZDO? zdo)
		{
			if (zdo == null)
			{
				return new List<KeyValuePair<long, string>>();
			}
			int safePermittedCount = GetSafePermittedCount(zdo);
			if (safePermittedCount <= 0)
			{
				return new List<KeyValuePair<long, string>>();
			}
			List<KeyValuePair<long, string>> list = new List<KeyValuePair<long, string>>(safePermittedCount);
			for (int i = 0; i < safePermittedCount; i++)
			{
				long num = zdo.GetLong(GetPermittedPlayerIdKey(i), 0L);
				if (num != 0L)
				{
					list.Add(new KeyValuePair<long, string>(num, zdo.GetString(GetPermittedPlayerNameKey(i), string.Empty) ?? string.Empty));
				}
			}
			return list;
		}

		internal static IReadOnlyList<long> GetPermittedPlayerIds(PrivateArea? area)
		{
			return GetPermittedPlayerIds(GetZdo(area));
		}

		internal static IReadOnlyList<long> GetPermittedPlayerIds(ZDO? zdo)
		{
			//IL_0017: 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 (zdo == null || !zdo.IsValid())
			{
				return Array.Empty<long>();
			}
			if (PermittedPlayerIdsCache.TryGetValue(zdo.m_uid, out CachedPermittedPlayerIds value) && value.Revision == zdo.DataRevision)
			{
				return value.PlayerIds;
			}
			long[] array = ReadPermittedPlayerIds(zdo);
			PermittedPlayerIdsCache[zdo.m_uid] = new CachedPermittedPlayerIds(zdo.DataRevision, array);
			return array;
		}

		internal static bool IsPlayerPermitted(PrivateArea? area, long playerId)
		{
			return IsPlayerPermitted(GetZdo(area), playerId);
		}

		internal static bool IsPlayerPermitted(ZDO? zdo, long playerId)
		{
			if (playerId == 0L)
			{
				return false;
			}
			if (zdo == null)
			{
				return false;
			}
			IReadOnlyList<long> permittedPlayerIds = GetPermittedPlayerIds(zdo);
			for (int i = 0; i < permittedPlayerIds.Count; i++)
			{
				if (permittedPlayerIds[i] == playerId)
				{
					return true;
				}
			}
			return false;
		}

		internal static bool AddPermittedPlayer(ZDO? zdo, long playerId, string playerName, out bool added)
		{
			added = false;
			if (zdo == null || !zdo.IsValid() || playerId == 0L)
			{
				return false;
			}
			List<KeyValuePair<long, string>> permittedPlayers = GetPermittedPlayers(zdo);
			for (int i = 0; i < permittedPlayers.Count; i++)
			{
				if (permittedPlayers[i].Key == playerId)
				{
					return true;
				}
			}
			if (permittedPlayers.Count >= 1024)
			{
				return false;
			}
			permittedPlayers.Add(new KeyValuePair<long, string>(playerId, playerName ?? string.Empty));
			SetPermittedPlayers(zdo, permittedPlayers);
			added = true;
			return true;
		}

		internal static bool RemovePermittedPlayer(ZDO? zdo, long playerId)
		{
			if (zdo == null || !zdo.IsValid() || playerId == 0L)
			{
				return false;
			}
			List<KeyValuePair<long, string>> permittedPlayers = GetPermittedPlayers(zdo);
			if (permittedPlayers.RemoveAll((KeyValuePair<long, string> entry) => entry.Key == playerId) == 0)
			{
				return false;
			}
			SetPermittedPlayers(zdo, permittedPlayers);
			return true;
		}

		internal static void ForgetPermittedPlayerIds(ZDOID zdoId)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!((ZDOID)(ref zdoId)).IsNone())
			{
				PermittedPlayerIdsCache.Remove(zdoId);
			}
		}

		internal static void ResetRuntimeState()
		{
			PermittedPlayerIdsCache.Clear();
		}

		private static long[] ReadPermittedPlayerIds(ZDO zdo)
		{
			int safePermittedCount = GetSafePermittedCount(zdo);
			if (safePermittedCount <= 0)
			{
				return Array.Empty<long>();
			}
			long[] array = new long[safePermittedCount];
			int num = 0;
			for (int i = 0; i < safePermittedCount; i++)
			{
				long num2 = zdo.GetLong(GetPermittedPlayerIdKey(i), 0L);
				if (num2 != 0L)
				{
					array[num] = num2;
					num++;
				}
			}
			if (num == 0)
			{
				return Array.Empty<long>();
			}
			if (num == array.Length)
			{
				return array;
			}
			long[] array2 = new long[num];
			Array.Copy(array, array2, num);
			return array2;
		}

		private static void SetPermittedPlayers(ZDO zdo, IReadOnlyList<KeyValuePair<long, string>> permittedPlayers)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			zdo.Set(ZDOVars.s_permitted, permittedPlayers.Count, false);
			for (int i = 0; i < permittedPlayers.Count; i++)
			{
				KeyValuePair<long, string> keyValuePair = permittedPlayers[i];
				zdo.Set(GetPermittedPlayerIdKey(i), keyValuePair.Key);
				zdo.Set(GetPermittedPlayerNameKey(i), keyValuePair.Value ?? string.Empty);
			}
			ForgetPermittedPlayerIds(zdo.m_uid);
		}

		private static int GetSafePermittedCount(ZDO zdo)
		{
			int num = zdo.GetInt(ZDOVars.s_permitted, 0);
			if (num >= 0 && num <= 1024)
			{
				return num;
			}
			return 0;
		}

		private static int GetPermittedPlayerIdKey(int index)
		{
			EnsurePermittedPlayerKeys(index);
			return PermittedPlayerIdKeys[index];
		}

		private static int GetPermittedPlayerNameKey(int index)
		{
			EnsurePermittedPlayerKeys(index);
			return PermittedPlayerNameKeys[index];
		}

		private static void EnsurePermittedPlayerKeys(int index)
		{
			while (PermittedPlayerIdKeys.Count <= index)
			{
				int count = PermittedPlayerIdKeys.Count;
				PermittedPlayerIdKeys.Add(StringExtensionMethods.GetStableHashCode($"pu_id{count}"));
				PermittedPlayerNameKeys.Add(StringExtensionMethods.GetStableHashCode($"pu_name{count}"));
			}
		}
	}
	internal readonly struct WardRecentPlayerEntry
	{
		internal long PlayerId { get; }

		internal string Name { get; }

		internal string GuildName { get; }

		internal string AccountId { get; }

		internal bool IsOnline { get; }

		internal long LastSeenUtcTicks { get; }

		internal WardRecentPlayerEntry(long playerId, string name, string guildName, string accountId, bool isOnline, long lastSeenUtcTicks)
		{
			PlayerId = playerId;
			Name = name ?? string.Empty;
			GuildName = guildName ?? string.Empty;
			AccountId = accountId ?? string.Empty;
			IsOnline = isOnline;
			LastSeenUtcTicks = lastSeenUtcTicks;
		}
	}
	internal readonly struct WardPlayerActivityEntry
	{
		internal long PlayerId { get; }

		internal bool IsOnline { get; }

		internal long LastSeenUtcTicks { get; }

		internal WardPlayerActivityEntry(long playerId, bool isOnline, long lastSeenUtcTicks)
		{
			PlayerId = playerId;
			IsOnline = isOnline;
			LastSeenUtcTicks = lastSeenUtcTicks;
		}
	}
	internal readonly struct WardRecentPlayersSnapshot
	{
		internal long RequestId { get; }

		internal ZDOID WardZdoId { get; }

		internal IReadOnlyList<WardRecentPlayerEntry> Players { get; }

		internal IReadOnlyList<WardPlayerActivityEntry> RegisteredActivity { get; }

		internal WardRecentPlayersSnapshot(long requestId, ZDOID wardZdoId, IReadOnlyList<WardRecentPlayerEntry> players, IReadOnlyList<WardPlayerActivityEntry> registeredActivity)
		{
			//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)
			RequestId = requestId;
			WardZdoId = wardZdoId;
			Players = players ?? Array.Empty<WardRecentPlayerEntry>();
			RegisteredActivity = registeredActivity ?? Array.Empty<WardPlayerActivityEntry>();
		}
	}
	internal static class WardRecentPlayers
	{
		private readonly struct SnapshotCandidate
		{
			internal StoredPlayer Player { get; }

			internal long PlayerId => Player.PlayerId;

			internal string Name { get; }

			internal string AccountId { get; }

			internal bool IsOnline { get; }

			internal long LastSeenUtcTicks { get; }

			internal SnapshotCandidate(StoredPlayer player, string name, string accountId, bool isOnline, long lastSeenUtcTicks)
			{
				Player = player;
				Name = name;
				AccountId = accountId;
				IsOnline = isOnline;
				LastSeenUtcTicks = lastSeenUtcTicks;
			}
		}

		private readonly struct RequestBudget
		{
			internal DateTime WindowStartedUtc { get; }

			internal int Count { get; }

			internal RequestBudget(DateTime windowStartedUtc, int count)
			{
				WindowStartedUtc = windowStartedUtc;
				Count = count;
			}
		}

		private sealed class RecentPlayersYaml
		{
			[YamlMember(Alias = "format_version")]
			public int FormatVersion { get; set; }

			[YamlMember(Alias = "world_uid")]
			public long WorldUid { get; set; }

			[YamlMember(Alias = "players")]
			public List<StoredPlayer>? Players { get; set; }
		}

		private sealed class StoredPlayer
		{
			[YamlMember(Alias = "player_id")]
			public long PlayerId { get; set; }

			[YamlMember(Alias = "name")]
			public string Name { get; set; } = string.Empty;

			[YamlMember(Alias = "account_id")]
			public string AccountId { get; set; } = string.Empty;

			[YamlMember(Alias = "last_seen_utc_ticks")]
			public long LastSeenUtcTicks { get; set; }
		}

		private const string RequestSnapshotRpc = "STUWard_RequestRecentPlayers";

		private const string RequestAddRpc = "STUWard_RequestAddRecentPlayer";

		private const string ReceiveSnapshotRpc = "STUWard_ReceiveRecentPlayers";

		private const string FileNamePrefix = "STUWard.RecentPlayers.";

		private const string FileNameSuffix = ".yml";

		private const int FormatVersion = 1;

		private const int MaxStoredPlayers = 4096;

		private const int MaxSnapshotPlayers = 1024;

		private const int MaxPlayerNameLength = 64;

		private const int MaxGuildNameLength = 256;

		private const int MaxAccountIdLength = 128;

		private const int MaxYamlBytes = 2097152;

		private const int MaxResponseBytes = 262144;

		private const int MaxRequestsPerWindow = 12;

		private static readonly TimeSpan RecentLifetime = TimeSpan.FromDays(14.0);

		private static readonly TimeSpan SaveDebounce = TimeSpan.FromSeconds(2.0);

		private static readonly TimeSpan SaveRetryDelay = TimeSpan.FromSeconds(10.0);

		private static readonly TimeSpan PruneInterval = TimeSpan.FromMinutes(5.0);

		private static readonly TimeSpan RequestWindow = TimeSpan.FromSeconds(2.0);

		private static readonly IDeserializer Deserializer = new DeserializerBuilder().WithDuplicateKeyChecking().Build();

		private static readonly ISerializer Serializer = new SerializerBuilder().Build();

		private static readonly Dictionary<long, StoredPlayer> PlayersById = new Dictionary<long, StoredPlayer>();

		private static readonly HashSet<long> OnlinePlayerIds = new HashSet<long>();

		private static readonly Dictionary<long, ServerSessionIdentity> AuthenticatedIdentitiesBySender = new Dictionary<long, ServerSessionIdentity>();

		private static readonly Dictionary<long, RequestBudget> RequestBudgetsBySender = new Dictionary<long, RequestBudget>();

		private static bool _rpcsRegistered;

		private static long _nextRequestId;

		private static long _loadedWorldUid;

		private static bool _serverStoreLoaded;

		private static bool _dirty;

		private static DateTime _saveAfterUtc = DateTime.MaxValue;

		private static DateTime _nextPruneUtc = DateTime.MinValue;

		internal static event Action<WardRecentPlayersSnapshot>? SnapshotReceived;

		internal static void RegisterRpcs()
		{
			ZRoutedRpc instance = ZRoutedRpc.instance;
			if (!_rpcsRegistered && instance != null)
			{
				instance.Register<ZPackage>("STUWard_RequestRecentPlayers", (Action<long, ZPackage>)HandleRequestSnapshot);
				instance.Register<ZPackage>("STUWard_RequestAddRecentPlayer", (Action<long, ZPackage>)HandleRequestAdd);
				instance.Register<ZPackage>("STUWard_ReceiveRecentPlayers", (Action<long, ZPackage>)HandleReceiveSnapshot);
				_rpcsRegistered = true;
			}
		}

		internal static void Update()
		{
			if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer())
			{
				EnsureServerStoreLoaded();
				DateTime utcNow = DateTime.UtcNow;
				if (utcNow >= _nextPruneUtc)
				{
					_nextPruneUtc = utcNow.Add(PruneInterval);
					RefreshAuthenticatedLastSeen(utcNow);
					PruneAndBound(utcNow);
				}
				if (_dirty && utcNow >= _saveAfterUtc)
				{
					SaveServerStore();
				}
			}
		}

		internal static void ResetRuntimeState()
		{
			FlushServerStore();
			_rpcsRegistered = false;
			_nextRequestId = 0L;
			_loadedWorldUid = 0L;
			_serverStoreLoaded = false;
			_dirty = false;
			_saveAfterUtc = DateTime.MaxValue;
			_nextPruneUtc = DateTime.MinValue;
			PlayersById.Clear();
			OnlinePlayerIds.Clear();
			AuthenticatedIdentitiesBySender.Clear();
			RequestBudgetsBySender.Clear();
		}

		internal static void Shutdown()
		{
			FlushServerStore();
		}

		internal static void RememberAuthenticatedIdentity(ServerSessionIdentity identity)
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || identity.PlayerId == 0L)
			{
				return;
			}
			if (AuthenticatedIdentitiesBySender.TryGetValue(identity.SenderUid, out var value) && value.PlayerId != identity.PlayerId)
			{
				AuthenticatedIdentitiesBySender[identity.SenderUid] = identity;
				RefreshOnlineState(value.PlayerId);
			}
			else
			{
				AuthenticatedIdentitiesBySender[identity.SenderUid] = identity;
			}
			if (EnsureServerStoreLoaded())
			{
				DateTime utcNow = DateTime.UtcNow;
				string text = NormalizeText(identity.PlayerName, 64);
				string text2 = NormalizeText(identity.AccountId, 128);
				if (PlayersById.TryGetValue(identity.PlayerId, out StoredPlayer value2))
				{
					value2.Name = ((!string.IsNullOrWhiteSpace(text)) ? text : value2.Name);
					value2.AccountId = ((!string.IsNullOrWhiteSpace(text2)) ? text2 : value2.AccountId);
					value2.LastSeenUtcTicks = utcNow.Ticks;
				}
				else
				{
					PlayersById[identity.PlayerId] = new StoredPlayer
					{
						PlayerId = identity.PlayerId,
						Name = text,
						AccountId = text2,
						LastSeenUtcTicks = utcNow.Ticks
					};
				}
				OnlinePlayerIds.Add(identity.PlayerId);
				MarkDirty(utcNow);
			}
		}

		internal static void ForgetAuthenticatedIdentity(ServerSessionIdentity identity)
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			AuthenticatedIdentitiesBySender.Remove(identity.SenderUid);
			RequestBudgetsBySender.Remove(identity.SenderUid);
			if (identity.PlayerId != 0L && EnsureServerStoreLoaded())
			{
				DateTime utcNow = DateTime.UtcNow;
				string text = NormalizeText(identity.PlayerName, 64);
				string text2 = NormalizeText(identity.AccountId, 128);
				if (!PlayersById.TryGetValue(identity.PlayerId, out StoredPlayer value))
				{
					value = new StoredPlayer
					{
						PlayerId = identity.PlayerId
					};
					PlayersById[identity.PlayerId] = value;
				}
				value.Name = ((!string.IsNullOrWhiteSpace(text)) ? text : value.Name);
				value.AccountId = ((!string.IsNullOrWhiteSpace(text2)) ? text2 : value.AccountId);
				value.LastSeenUtcTicks = utcNow.Ticks;
				RefreshOnlineState(identity.PlayerId);
				MarkDirty(utcNow);
			}
		}

		internal static void RememberLocalServerPlayer(Player? player)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null || (Object)(object)player != (Object)(object)Player.m_localPlayer || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			long playerID = player.GetPlayerID();
			long num = ((Character)player).GetOwner();
			if (playerID != 0L)
			{
				if (num == 0L)
				{
					num = ZDOMan.GetSessionID();
				}
				RememberAuthenticatedIdentity(new ServerSessionIdentity(num, ZDOID.None, playerID, WardOwnership.GetPlayerAccountId(player), player.GetPlayerName()));
			}
		}

		internal static long RequestSnapshot(PrivateArea? ward)
		{
			return SendRequest(ward, 0L, "STUWard_RequestRecentPlayers");
		}

		internal static long RequestAdd(PrivateArea? ward, long playerId)
		{
			if (playerId == 0L)
			{
				return 0L;
			}
			return SendRequest(ward, playerId, "STUWard_RequestAddRecentPlayer");
		}

		private static long SendRequest(PrivateArea? ward, long targetPlayerId, string method)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			RegisterRpcs();
			ZDO zdo = WardPrivateAreaSafeAccess.GetZdo(ward);
			if (zdo == null || !zdo.IsValid() || ZRoutedRpc.instance == null)
			{
				return 0L;
			}
			long num = NextRequestId();
			ZPackage val = new ZPackage();
			val.Write(num);
			val.Write(zdo.m_uid);
			if (targetPlayerId != 0L)
			{
				val.Write(targetPlayerId);
			}
			if (!WardOwnership.TryInvokeServerRoutedRpc(method, val))
			{
				return 0L;
			}
			return num;
		}

		private static void HandleRequestSnapshot(long sender, ZPackage? request)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (TryConsumeRequestBudget(sender) && TryReadWardRequest(request, out var requestId, out var wardZdoId) && TryAuthorize(sender, wardZdoId, out ZDO zdo, out long _))
			{
				SendSnapshot(sender, requestId, zdo);
			}
		}

		private static void HandleRequestAdd(long sender, ZPackage? request)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (!TryConsumeRequestBudget(sender) || !TryReadAddRequest(request, out var requestId, out var wardZdoId, out var targetPlayerId) || !TryAuthorize(sender, wardZdoId, out ZDO zdo, out long _))
			{
				return;
			}
			if (!TryGetEligibleTarget(targetPlayerId, DateTime.UtcNow, out StoredPlayer player))
			{
				SendSnapshot(sender, requestId, zdo);
				return;
			}
			if (zdo.GetLong(ZDOVars.s_creator, 0L) != targetPlayerId && !WardPrivateAreaSafeAccess.IsPlayerPermitted(zdo, targetPlayerId))
			{
				WardOwnership.RefreshServerPlayerAccountIdForResolvedPlayer(targetPlayerId, player.AccountId);
				if (!WardOwnership.TryClaimManagedWardMutationOwnership(zdo) || !WardPrivateAreaSafeAccess.AddPermittedPlayer(zdo, targetPlayerId, GetDisplayName(player), out var added))
				{
					SendSnapshot(sender, requestId, zdo);
					return;
				}
				if (added)
				{
					WardOwnership.CompleteAuthoritativePermittedMutation(zdo);
				}
			}
			SendSnapshot(sender, requestId, zdo);
		}

		private static bool TryAuthorize(long sender, ZDOID wardZdoId, out ZDO zdo, out long requesterId)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			zdo = null;
			requesterId = 0L;
			if (WardOwnership.TryResolveAuthoritativeManagedWardRequest(sender, wardZdoId, out zdo, out requesterId))
			{
				return WardAccess.HasManagedWardTrust(zdo, requesterId);
			}
			return false;
		}

		private static void SendSnapshot(long receiverUid, long requestId, ZDO wardZdo)
		{
			//IL_0035: 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_0074: 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_00b8: Unknown result type (might be due to invalid IL or missing references)
			if (receiverUid == 0L || requestId <= 0 || !EnsureServerStoreLoaded())
			{
				return;
			}
			DateTime utcNow = DateTime.UtcNow;
			IReadOnlyList<long> permittedPlayerIds = WardPrivateAreaSafeAccess.GetPermittedPlayerIds(wardZdo);
			HashSet<long> permittedPlayerIds2 = new HashSet<long>(permittedPlayerIds);
			List<WardRecentPlayerEntry> entries = BuildSnapshot(wardZdo, permittedPlayerIds2, utcNow);
			List<WardPlayerActivityEntry> registeredActivity = BuildRegisteredActivity(permittedPlayerIds);
			int snapshotPrefixCount = GetSnapshotPrefixCount(requestId, wardZdo.m_uid, entries, registeredActivity);
			ZPackage val = CreateSnapshotResponse(requestId, wardZdo.m_uid, entries, snapshotPrefixCount, registeredActivity);
			byte[] array = val.GetArray();
			if (array.Length > 262144)
			{
				Plugin.Log.LogWarning((object)$"Recent-player response for ward {wardZdo.m_uid} exceeded the size limit; omitting unregistered players.");
				val = CreateSnapshotResponse(requestId, wardZdo.m_uid, entries, 0, registeredActivity);
				array = val.GetArray();
			}
			if (array.Length > 262144)
			{
				Plugin.Log.LogError((object)$"Registered-player activity response for ward {wardZdo.m_uid} exceeded the size limit.");
				return;
			}
			ZRoutedRpc instance = ZRoutedRpc.instance;
			if (instance != null)
			{
				instance.InvokeRoutedRPC(receiverUid, "STUWard_ReceiveRecentPlayers", new object[1] { val });
			}
		}

		private static int GetSnapshotPrefixCount(long requestId, ZDOID wardZdoId, IReadOnlyList<WardRecentPlayerEntry> entries, IReadOnlyList<WardPlayerActivityEntry> registeredActivity)
		{
			//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_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			//IL_002a: 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_003c: Expected O, but got Unknown
			//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_007b: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			WriteSnapshotHeader(val, requestId, wardZdoId, 0, registeredActivity.Count);
			int num = val.GetArray().Length;
			if (num > 262144)
			{
				return 0;
			}
			for (int i = 0; i < registeredActivity.Count; i++)
			{
				ZPackage val2 = new ZPackage();
				WriteActivityEntry(val2, registeredActivity[i]);
				int num2 = val2.GetArray().Length;
				if (num2 > 262144 - num)
				{
					return 0;
				}
				num += num2;
			}
			int num3 = 0;
			for (int j = 0; j < entries.Count; j++)
			{
				ZPackage val3 = new ZPackage();
				WriteSnapshotEntry(val3, entries[j]);
				int num4 = val3.GetArray().Length;
				if (num4 > 262144 - num)
				{
					break;
				}
				num += num4;
				num3++;
			}
			return num3;
		}

		private static ZPackage CreateSnapshotResponse(long requestId, ZDOID wardZdoId, IReadOnlyList<WardRecentPlayerEntry> entries, int count, IReadOnlyList<WardPlayerActivityEntry> registeredActivity)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			ZPackage val = new ZPackage();
			WriteSnapshotHeader(val, requestId, wardZdoId, count, registeredActivity.Count);
			for (int i = 0; i < count; i++)
			{
				WriteSnapshotEntry(val, entries[i]);
			}
			for (int j = 0; j < registeredActivity.Count; j++)
			{
				WriteActivityEntry(val, registeredActivity[j]);
			}
			return val;
		}

		private static void WriteSnapshotHeader(ZPackage response, long requestId, ZDOID wardZdoId, int unregisteredCount, int registeredActivityCount)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			response.Write(requestId);
			response.Write(wardZdoId);
			response.Write(unregisteredCount);
			response.Write(registeredActivityCount);
		}

		private static void WriteSnapshotEntry(ZPackage response, WardRecentPlayerEntry entry)
		{
			response.Write(entry.PlayerId);
			response.Write(entry.Name);
			response.Write(entry.GuildName);
			response.Write(entry.AccountId);
			response.Write(entry.IsOnline);
			response.Write(entry.LastSeenUtcTicks);
		}

		private static void WriteActivityEntry(ZPackage response, WardPlayerActivityEntry entry)
		{
			response.Write(entry.PlayerId);
			response.Write(entry.IsOnline);
			response.Write(entry.LastSeenUtcTicks);
		}

		private static List<WardRecentPlayerEntry> BuildSnapshot(ZDO wardZdo, HashSet<long> permittedPlayerIds, DateTime nowUtc)
		{
			PruneAndBound(nowUtc);
			long num = wardZdo.GetLong(ZDOVars.s_creator, 0L);
			List<SnapshotCandidate> list = new List<SnapshotCandidate>();
			foreach (StoredPlayer value in PlayersById.Values)
			{
				bool flag = OnlinePlayerIds.Contains(value.PlayerId);
				if (value.PlayerId != 0L && value.PlayerId != num && !permittedPlayerIds.Contains(value.PlayerId) && (flag || IsRecent(value, nowUtc)))
				{
					list.Add(new SnapshotCandidate(value, GetDisplayName(value), GetDisplayAccountId(value), flag, value.LastSeenUtcTicks));
				}
			}
			list.Sort(CompareCandidates);
			if (list.Count > 1024)
			{
				list.RemoveRange(1024, list.Count - 1024);
			}
			List<WardRecentPlayerEntry> list2 = new List<WardRecentPlayerEntry>(list.Count);
			for (int i = 0; i < list.Count; i++)
			{
				SnapshotCandidate snapshotCandidate = list[i];
				list2.Add(new WardRecentPlayerEntry(snapshotCandidate.Player.PlayerId, snapshotCandidate.Name, GetAuthoritativeGuildName(snapshotCandidate.Player), snapshotCandidate.AccountId, snapshotCandidate.IsOnline, snapshotCandidate.LastSeenUtcTicks));
			}
			return list2;
		}

		private static List<WardPlayerActivityEntry> BuildRegisteredActivity(IReadOnlyList<long> permittedPlayerIds)
		{
			List<WardPlayerActivityEntry> list = new List<WardPlayerActivityEntry>(Math.Min(permittedPlayerIds.Count, 1024));
			for (int i = 0; i < permittedPlayerIds.Count; i++)
			{
				if (list.Count >= 1024)
				{
					break;
				}
				long num = permittedPlayerIds[i];
				if (num != 0L && PlayersById.TryGetValue(num, out StoredPlayer value))
				{
					list.Add(new WardPlayerActivityEntry(num, OnlinePlayerIds.Contains(num), value.LastSeenUtcTicks));
				}
			}
			return list;
		}

		private static int CompareCandidates(SnapshotCandidate left, SnapshotCandidate right)
		{
			int num = right.IsOnline.CompareTo(left.IsOnline);
			if (num != 0)
			{
				return num;
			}
			int num2 = right.LastSeenUtcTicks.CompareTo(left.LastSeenUtcTicks);
			if (num2 != 0)
			{
				return num2;
			}
			int num3 = StringComparer.OrdinalIgnoreCase.Compare(left.Name, right.Name);
			if (num3 == 0)
			{
				return left.PlayerId.CompareTo(right.PlayerId);
			}
			return num3;
		}

		private static void HandleReceiveSnapshot(long sender, ZPackage? response)
		{
			//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_00eb: Unknown result type (might be due to invalid IL or missing references)
			if (!WardOwnership.IsAuthoritativeServerSender(sender) || response == null)
			{
				return;
			}
			try
			{
				if (response.GetArray().Length > 262144)
				{
					return;
				}
				long num = response.ReadLong();
				ZDOID wardZdoId = response.ReadZDOID();
				int num2 = response.ReadInt();
				int num3 = response.ReadInt();
				if (num <= 0 || ((ZDOID)(ref wardZdoId)).IsNone() || num2 < 0 || num2 > 1024 || num3 < 0 || num3 > 1024)
				{
					return;
				}
				DateTime maximumLastSeenUtc = DateTime.UtcNow.AddMinutes(5.0);
				List<WardRecentPlayerEntry> list = new List<WardRecentPlayerEntry>(num2);
				for (int i = 0; i < num2; i++)
				{
					if (!TryReadSnapshotEntry(response, maximumLastSeenUtc, out var entry))
					{
						return;
					}
					list.Add(entry);
				}
				List<WardPlayerActivityEntry> list2 = new List<WardPlayerActivityEntry>(num3);
				for (int j = 0; j < num3; j++)
				{
					if (!TryReadActivityEntry(response, maximumLastSeenUtc, out var entry2))
					{
						return;
					}
					list2.Add(entry2);
				}
				WardRecentPlayers.SnapshotReceived?.Invoke(new WardRecentPlayersSnapshot(num, wardZdoId, list, list2));
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Rejected malformed recent-player response: " + ex.Message));
			}
		}

		private static bool TryReadSnapshotEntry(ZPackage response, DateTime maximumLastSeenUtc, out WardRecentPlayerEntry entry)
		{
			entry = default(WardRecentPlayerEntry);
			long num = response.ReadLong();
			string text = response.ReadString();
			string text2 = response.ReadString();
			string text3 = response.ReadString();
			bool isOnline = response.ReadBool();
			long num2 = response.ReadLong();
			if (num == 0L || text.Length > 64 || text2.Length > 256 || text3.Length > 128 || !IsPlausibleLastSeen(num2, maximumLastSeenUtc))
			{
				return false;
			}
			entry = new WardRecentPlayerEntry(num, text, text2, text3, isOnline, num2);
			return true;
		}

		private static bool TryReadActivityEntry(ZPackage response, DateTime maximumLastSeenUtc, out WardPlayerActivityEntry entry)
		{
			entry = default(WardPlayerActivityEntry);
			long num = response.ReadLong();
			bool isOnline = response.ReadBool();
			long num2 = response.ReadLong();
			if (num == 0L || num2 <= 0 || !IsPlausibleLastSeen(num2, maximumLastSeenUtc))
			{
				return false;
			}
			entry = new WardPlayerActivityEntry(num, isOnline, num2);
			return true;
		}

		private static bool TryReadWardRequest(ZPackage? request, out long requestId, out ZDOID wardZdoId)
		{
			//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_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)
			requestId = 0L;
			wardZdoId = ZDOID.None;
			if (request == null)
			{
				return false;
			}
			try
			{
				requestId = request.ReadLong();
				wardZdoId = request.ReadZDOID();
				return requestId > 0 && !((ZDOID)(ref wardZdoId)).IsNone();
			}
			catch
			{
				return false;
			}
		}

		private static bool TryReadAddRequest(ZPackage? request, out long requestId, out ZDOID wardZdoId, out long targetPlayerId)
		{
			targetPlayerId = 0L;
			if (!TryReadWardRequest(request, out requestId, out wardZdoId))
			{
				return false;
			}
			try
			{
				targetPlayerId = request.ReadLong();
				return targetPlayerId != 0;
			}
			catch
			{
				return false;
			}
		}

		private static bool TryGetEligibleTarget(long playerId, DateTime nowUtc, out StoredPlayer player)
		{
			if (!EnsureServerStoreLoaded())
			{
				player = null;
				return false;
			}
			if (playerId != 0L && PlayersById.TryGetValue(playerId, out player))
			{
				if (!OnlinePlayerIds.Contains(playerId))
				{
					return IsRecent(player, nowUtc);
				}
				return true;
			}
			player = null;
			return false;
		}

		private static bool IsRecent(StoredPlayer player, DateTime nowUtc)
		{
			if (IsPlausibleLastSeen(player.LastSeenUtcTicks, nowUtc))
			{
				return nowUtc.Ticks - player.LastSeenUtcTicks <= RecentLifetime.Ticks;
			}
			return false;
		}

		private static long NextRequestId()
		{
			_nextRequestId++;
			if (_nextRequestId <= 0)
			{
				_nextRequestId = 1L;
			}
			return _nextRequestId;
		}

		private static bool EnsureServerStoreLoaded()
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return false;
			}
			long worldUID = ZNet.instance.GetWorldUID();
			if (worldUID == 0L)
			{
				return false;
			}
			if (_serverStoreLoaded && _loadedWorldUid == worldUID)
			{
				return true;
			}
			if (_serverStoreLoaded)
			{
				FlushServerStore();
			}
			PlayersById.Clear();
			OnlinePlayerIds.Clear();
			_dirty = false;
			_loadedWorldUid = worldUID;
			_serverStoreLoaded = true;
			_nextPruneUtc = DateTime.UtcNow.Add(PruneInterval);
			LoadServerStore();
			ReconcileAuthenticatedIdentities();
			return true;
		}

		private static void LoadServerStore()
		{
			string filePath = GetFilePath(_loadedWorldUid);
			if (!File.Exists(filePath))
			{
				return;
			}
			try
			{
				FileInfo fileInfo = new FileInfo(filePath);
				if (fileInfo.Length < 0 || fileInfo.Length > 2097152)
				{
					Plugin.Log.LogWarning((object)("Recent-player file '" + filePath + "' exceeds the size limit; starting empty."));
					return;
				}
				RecentPlayersYaml recentPlayersYaml = Deserializer.Deserialize<RecentPlayersYaml>(File.ReadAllText(filePath));
				if (recentPlayersYaml == null || recentPlayersYaml.FormatVersion != 1 || recentPlayersYaml.WorldUid != _loadedWorldUid || recentPlayersYaml.Players == null)
				{
					Plugin.Log.LogWarning((object)("Recent-player file '" + filePath + "' has an unsupported format or world id; starting empty."));
					return;
				}
				if (recentPlayersYaml.Players.Count > 4096)
				{
					Plugin.Log.LogWarning((object)("Recent-player file '" + filePath + "' has too many entries; starting empty."));
					return;
				}
				DateTime utcNow = DateTime.UtcNow;
				DateTime maximumUtc = utcNow.AddMinutes(5.0);
				for (int i = 0; i < recentPlayersYaml.Players.Count; i++)
				{
					StoredPlayer storedPlayer = recentPlayersYaml.Players[i];
					if (storedPlayer == null || storedPlayer.PlayerId == 0L || !IsPlausibleLastSeen(storedPlayer.LastSeenUtcTicks, maximumUtc) || (storedPlayer.Name?.Length ?? 0) > 64 || (storedPlayer.AccountId?.Length ?? 0) > 128)
					{
						Plugin.Log.LogWarning((object)("Recent-player file '" + filePath + "' is invalid; starting empty."));
						PlayersById.Clear();
						return;
					}
					PlayersById[storedPlayer.PlayerId] = new StoredPlayer
					{
						PlayerId = storedPlayer.PlayerId,
						Name = (storedPlayer.Name ?? string.Empty),
						AccountId = (storedPlayer.AccountId ?? string.Empty),
						LastSeenUtcTicks = Math.Min(storedPlayer.LastSeenUtcTicks, utcNow.Ticks)
					};
				}
				PruneAndBound(utcNow);
			}
			catch (Exception ex)
			{
				PlayersById.Clear();
				Plugin.Log.LogWarning((object)("Failed to read recent-player file '" + filePath + "'; starting empty: " + ex.Message));
			}
		}

		private static void SaveServerStore()
		{
			if (!_serverStoreLoaded || _loadedWorldUid == 0L)
			{
				return;
			}
			PruneAndBound(DateTime.UtcNow);
			RecentPlayersYaml recentPlayersYaml = new RecentPlayersYaml
			{
				FormatVersion = 1,
				WorldUid = _loadedWorldUid,
				Players = new List<StoredPlayer>(PlayersById.Values)
			};
			recentPlayersYaml.Players.Sort((StoredPlayer left, StoredPlayer right) => left.PlayerId.CompareTo(right.PlayerId));
			try
			{
				string text = Serializer.Serialize(recentPlayersYaml);
				if (Encoding.UTF8.GetByteCount(text) > 2097152)
				{
					Plugin.Log.LogWarning((object)"Recent-player data exceeded the file size limit and was not saved.");
					_saveAfterUtc = DateTime.UtcNow.Add(SaveRetryDelay);
					return;
				}
				string filePath = GetFilePath(_loadedWorldUid);
				string text2 = filePath + ".tmp";
				File.WriteAllText(text2, text);
				if (File.Exists(filePath))
				{
					File.Replace(text2, filePath, null);
				}
				else
				{
					File.Move(text2, filePath);
				}
				_dirty = false;
				_saveAfterUtc = DateTime.MaxValue;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Failed to save recent-player data: " + ex.Message));
				_saveAfterUtc = DateTime.UtcNow.Add(SaveRetryDelay);
			}
		}

		private static void FlushServerStore()
		{
			if (_serverStoreLoaded)
			{
				RefreshAuthenticatedLastSeen(DateTime.UtcNow);
				if (_dirty)
				{
					SaveServerStore();
				}
			}
		}

		private static void RefreshAuthenticatedLastSeen(DateTime nowUtc)
		{
			bool flag = false;
			foreach (ServerSessionIdentity value2 in AuthenticatedIdentitiesBySender.Values)
			{
				if (value2.PlayerId != 0L && PlayersById.TryGetValue(value2.PlayerId, out StoredPlayer value) && value.LastSeenUtcTicks != nowUtc.Ticks)
				{
					value.LastSeenUtcTicks = nowUtc.Ticks;
					flag = true;
				}
			}
			if (flag)
			{
				MarkDirty(nowUtc);
			}
		}

		private static void PruneAndBound(DateTime nowUtc)
		{
			List<long> list = null;
			foreach (KeyValuePair<long, StoredPlayer> item in PlayersById)
			{
				if (!OnlinePlayerIds.Contains(item.Key) && !IsRecent(item.Value, nowUtc))
				{
					if (list == null)
					{
						list = new List<long>();
					}
					list.Add(item.Key);
				}
			}
			if (list != null)
			{
				for (int i = 0; i < list.Count; i++)
				{
					PlayersById.Remove(list[i]);
				}
				MarkDirty(nowUtc);
			}
			if (PlayersById.Count <= 4096)
			{
				return;
			}
			List<StoredPlayer> list2 = new List<StoredPlayer>(PlayersById.Values);
			list2.Sort(delegate(StoredPlayer left, StoredPlayer right)
			{
				int num2 = OnlinePlayerIds.Contains(right.PlayerId).CompareTo(OnlinePlayerIds.Contains(left.PlayerId));
				return (num2 == 0) ? right.LastSeenUtcTicks.CompareTo(left.LastSeenUtcTicks) : num2;
			});
			for (int num = 4096; num < list2.Count; num++)
			{
				if (!OnlinePlayerIds.Contains(list2[num].PlayerId))
				{
					PlayersById.Remove(list2[num].PlayerId);
				}
			}
			MarkDirty(nowUtc);
		}

		private static void MarkDirty(DateTime nowUtc)
		{
			_dirty = true;
			DateTime dateTime = nowUtc.Add(SaveDebounce);
			if (_saveAfterUtc == DateTime.MaxValue || dateTime < _saveAfterUtc)
			{
				_saveAfterUtc = dateTime;
			}
		}

		private static string GetFilePath(long worldUid)
		{
			return Path.Combine(Paths.ConfigPath, "STUWard.RecentPlayers." + worldUid + ".yml");
		}

		private static string GetDisplayName(StoredPlayer player)
		{
			string text = NormalizeText(player.Name, 64);
			if (!string.IsNullOrWhiteSpace(text))
			{
				return text;
			}
			return player.PlayerId.ToString();
		}

		private static string GetAuthoritativeGuildName(StoredPlayer player)
		{
			string accountId = WardOwnership.NormalizeAccountIdValue(player.AccountId);
			string playerName = NormalizeText(player.Name, 64);
			if (!GuildsCompat.TryResolveCachedAuthoritativeGuildIdentity(player.PlayerId, accountId, playerName, out var guild) || guild.Id == 0)
			{
				return string.Empty;
			}
			return NormalizeText(guild.Name, 256);
		}

		private static string GetDisplayAccountId(StoredPlayer player)
		{
			return NormalizeText(WardOwnership.NormalizeAccountIdValue(player.AccountId), 128);
		}

		private static string NormalizeText(string? value, int maxLength)
		{
			string text = (value ?? string.Empty).Trim();
			if (text.Length > maxLength)
			{
				text = text.Substring(0, maxLength);
			}
			return text;
		}

		private static bool IsPlausibleLastSeen(long ticks, DateTime maximumUtc)
		{
			if (ticks >= DateTime.MinValue.Ticks && ticks <= DateTime.MaxValue.Ticks)
			{
				return ticks <= maximumUtc.Ticks;
			}
			return false;
		}

		private static void ReconcileAuthenticatedIdentities()
		{
			if (_serverStoreLoaded)
			{
				List<ServerSessionIdentity> list = new List<ServerSessionIdentity>(AuthenticatedIdentitiesBySender.Values);
				for (int i = 0; i < list.Count; i++)
				{
					RememberAuthenticatedIdentity(list[i]);
				}
			}
		}

		private static void RefreshOnlineState(long playerId)
		{
			foreach (ServerSessionIdentity value in AuthenticatedIdentitiesBySender.Values)
			{
				if (value.PlayerId == playerId)
				{
					OnlinePlayerIds.Add(playerId);
					return;
				}
			}
			OnlinePlayerIds.Remove(playerId);
		}

		private static bool TryConsumeRequestBudget(long sender)
		{
			if (sender == 0L)
			{
				return false;
			}
			DateTime utcNow = DateTime.UtcNow;
			if (!RequestBudgetsBySender.TryGetValue(sender, out var value) || utcNow - value.WindowStartedUtc >= RequestWindow)
			{
				RequestBudgetsBySender[sender] = new RequestBudget(utcNow, 1);
				return true;
			}
			if (value.Count >= 12)
			{
				return false;
			}
			RequestBudgetsBySender[sender] = new RequestBudget(value.WindowStartedUtc, value.Count + 1);
			return true;
		}
	}
	internal static class WardAdminDebugAccess
	{
		private const string RpcSetAdminDebugState = "STUWard_SetAdminDebugState";

		private const string RpcReceiveAdminDebugState = "STUWard_ReceiveAdminDebugState";

		private static readonly TimeSpan DebugStateResendInterval = TimeSpan.FromSeconds(3.0);

		private static readonly HashSet<long> ServerDebugAdminPlayerIds = new HashSet<long>();

		private static bool _rpcsRegistered;

		private static bool? _lastLocalDebugAdminState;

		private static bool _serverApprovedLocalDebugState;

		private static DateTime _lastLocalDebugAdminSyncUtc = DateTime.MinValue;

		internal static void ResetRuntimeState()
		{
			_rpcsRegistered = false;
			_lastLocalDebugAdminState = null;
			_serverApprovedLocalDebugState = false;
			_lastLocalDebugAdminSyncUtc = DateTime.MinValue;
			ServerDebugAdminPlayerIds.Clear();
		}

		internal static void EnsureRuntimeBindings()
		{
			RegisterRpcs();
		}

		internal static void RegisterRpcs()
		{
			ZRoutedRpc instance = ZRoutedRpc.instance;
			if (!_rpcsRegistered && instance != null)
			{
				instance.Register<bool>("STUWard_SetAdminDebugState", (Action<long, bool>)HandleSetAdminDebugState);
				instance.Register<bool>("STUWard_ReceiveAdminDebugState", (Action<long, bool>)HandleReceiveAdminDebugState);
				_rpcsRegistered = true;
			}
		}

		internal static void UpdateLocalState(Player? player, bool force = false)
		{
			if ((Object)(object)player == (Object)null || (Object)(object)player != (Object)(object)Player.m_localPlayer || (Object)(object)ZNet.instance == (Object)null)
			{
				return;
			}
			bool flag = IsLocalAdminDebugRequested(player);
			DateTime utcNow = DateTime.UtcNow;
			if (ZNet.instance.IsServer())
			{
				if (force || !_lastLocalDebugAdminState.HasValue || _lastLocalDebugAdminState.Value != flag)
				{
					_lastLocalDebugAdminState = flag;
					_lastLocalDebugAdminSyncUtc = utcNow;
					SetServerAdminDebugState(player.GetPlayerID(), flag);
				}
				return;
			}
			bool flag2 = !_lastLocalDebugAdminState.HasValue || _lastLocalDebugAdminState.Value != flag;
			bool flag3 = flag && utcNow - _lastLocalDebugAdminSyncUtc >= DebugStateResendInterval;
			if (force || flag2 || flag3)
			{
				_lastLocalDebugAdminState = flag;
				_lastLocalDebugAdminSyncUtc = utcNow;
				RegisterRpcs();
				ZRoutedRpc instance = ZRoutedRpc.instance;
				if (instance != null)
				{
					instance.InvokeRoutedRPC("STUWard_SetAdminDebugState", new object[1] { flag });
				}
			}
		}

		internal static bool CanLocallyAttemptAnyWardControl(PrivateArea? area, Player? player)
		{
			if ((Object)(object)area != (Object)null && (Object)(object)player != (Object)null && (Object)(object)player == (Object)(object)Player.m_localPlayer && WardAccess.IsManagedWard(area, requireEnabled: false))
			{
				return Player.m_debugMode;
			}
			return false;
		}

		internal static bool IsPlayerAdminDebugController(long playerId)
		{
			if (playerId == 0L)
			{
				return false;
			}
			if ((Object)(object)Player.m_localPlayer != (Object)null && Player.m_localPlayer.GetPlayerID() == playerId && IsLocalAdminDebugController(Player.m_localPlayer))
			{
				return true;
			}
			if (!ServerDebugAdminPlayerIds.Contains(playerId))
			{
				return false;
			}
			if (IsAdminAccountId(WardOwnership.GetPlayerAccountId(playerId)))
			{
				return true;
			}
			ServerDebugAdminPlayerIds.Remove(playerId);
			return false;
		}

		internal static void ForgetServerPlayer(long playerId)
		{
			if (playerId != 0L)
			{
				ServerDebugAdminPlayerIds.Remove(playerId);
			}
		}

		private static bool IsLocalAdminDebugController(Player? player)
		{
			if ((Object)(object)player == (Object)null || (Object)(object)player != (Object)(object)Player.m_localPlayer || !Player.m_debugMode || (Object)(object)ZNet.instance == (Object)null)
			{
				return false;
			}
			if (ZNet.instance.IsServer())
			{
				return true;
			}
			string playerAccountId = WardOwnership.GetPlayerAccountId(player.GetPlayerID());
			if ((Object)(object)player != (Object)null)
			{
				if (!_serverApprovedLocalDebugState && !IsAdminAccountId(playerAccountId))
				{
					return ZNet.instance.LocalPlayerIsAdminOrHost();
				}
				return true;
			}
			return false;
		}

		private static bool IsLocalAdminDebugRequested(Player? player)
		{
			if ((Object)(object)player != (Object)null && (Object)(object)player == (Object)(object)Player.m_localPlayer && Player.m_debugMode)
			{
				return (Object)(object)ZNet.instance != (Object)null;
			}
			return false;
		}

		private static void HandleSetAdminDebugState(long sender, bool enabled)
		{
			if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer() && WardOwnership.TryResolveAuthoritativePlayerIdFromSender(sender, out var playerId))
			{
				if (!enabled)
				{
					ServerDebugAdminPlayerIds.Remove(playerId);
					SendAdminDebugStateResponse(sender, enabled: false);
				}
				else if (!IsAdminAccountId(WardOwnership.GetAuthoritativeAccountIdFromSender(sender, playerId)))
				{
					ServerDebugAdminPlayerIds.Remove(playerId);
					SendAdminDebugStateResponse(sender, enabled: false);
				}
				else
				{
					ServerDebugAdminPlayerIds.Add(playerId);
					SendAdminDebugStateResponse(sender, enabled: true);
				}
			}
		}

		private static void HandleReceiveAdminDebugState(long sender, bool enabled)
		{
			if (WardOwnership.IsAuthoritativeServerSender(sender))
			{
				_serverApprovedLocalDebugState = enabled;
				_lastLocalDebugAdminSyncUtc = DateTime.UtcNow;
			}
		}

		private static void SendAdminDebugStateResponse(long receiverUid, bool enabled)
		{
			if (receiverUid != 0L)
			{
				ZRoutedRpc instance = ZRoutedRpc.instance;
				if (instance != null)
				{
					instance.InvokeRoutedRPC(receiverUid, "STUWard_ReceiveAdminDebugState", new object[1] { enabled });
				}
			}
		}

		private static void SetServerAdminDebugState(long playerId, bool enabled)
		{
			if (playerId != 0L)
			{
				if (enabled)
				{
					ServerDebugAdminPlayerIds.Add(playerId);
				}
				else
				{
					ServerDebugAdminPlayerIds.Remove(playerId);
				}
			}
		}

		internal static bool IsAdminAccountId(string accountId)
		{
			ZNet instance = ZNet.instance;
			List<string> list = ((instance != null) ? instance.GetAdminList() : null);
			if (list == null || string.IsNullOrWhiteSpace(accountId))
			{
				return false;
			}
			string b = NormalizeAccountId(accountId);
			for (int i = 0; i < list.Count; i++)
			{
				if (string.Equals(NormalizeAccountId(list[i]), b, StringComparison.Ordinal))
				{
					return true;
				}
			}
			return false;
		}

		private static string NormalizeAccountId(string? rawAccountId)
		{
			if (string.IsNullOrWhiteSpace(rawAccountId))
			{
				return string.Empty;
			}
			return WardOwnership.NormalizeAccountIdValue(rawAccountId);
		}
	}
	[HarmonyPatch(typeof(Player), "Update")]
	internal static class PlayerUpdateWardAdminDebugPatch
	{
		private static void Postfix(Player __instance)
		{
			WardAdminDebugAccess.UpdateLocalState(__instance);
		}
	}
	internal static class ManagedWardInitializationCoordinator
	{
		internal static void EnsureLocalInitialization(PrivateArea area)
		{
			if (!((Object)(object)area == (Object)null) && ManagedWardIdentity.EnsureManagedComponent(area))
			{
				WardSettings.CaptureNativeAreaMarkerSpeed(area);
			}
		}

		internal static bool TryGetValidZdo(ManagedWardRef ward, out ZDO zdo)
		{
			zdo = null;
			if (!ward.HasValidNetworkIdentity)
			{
				return false;
			}
			zdo = ward.Zdo;
			return true;
		}
	}
	internal static class ManagedWardLifecycle
	{
		internal static void NotifyAreaReady(PrivateArea? area, bool matchedByComponent, bool matchedByZdo)
		{
			ManagedWardRef ward = ManagedWardRef.FromArea(area);
			if (!((Object)(object)area == (Object)null) && (matchedByComponent || matchedByZdo) && ManagedWardInitializationCoordinator.TryGetValidZdo(ward, out ZDO _) && ManagedWardIdentity.EnsureManagedComponent(ward))
			{
				ManagedWardInitializationCoordinator.EnsureLocalInitialization(area);
				ManagedWardRuntimeContext orCreate = ManagedWardRuntimeContexts.GetOrCreate(area);
				if (!orCreate.NetworkInitializationComplete)
				{
					WardOwnership.TryStampLocalManagedWardOwnerAccount(ward);
					WardAccess.RegisterManagedWard(ward);
					WardPermittedSnapshots.Backfill(ward);
					WardSettings.ApplyAreaState(ward);
					orCreate.NetworkInitializationComplete = true;
				}
				if (!orCreate.OwnershipObserved)
				{
					WardOwnership.ObserveManagedWard(ward);
					orCreate.OwnershipObserved = true;
				}
			}
		}

		internal static void NotifyAreaDestroyed(PrivateArea? area)
		{
			if (!((Object)(object)area == (Object)null))
			{
				WardAccess.UnregisterManagedWard(area);
				ManagedWardRuntimeContexts.Forget(area);
			}
		}

		internal static void NotifySessionReset()
		{
			ManagedWardRuntimeLifecycle.ResetSession();
			ManagedWardRuntimeLifecycle.BindNetwork();
		}
	}
	[HarmonyPatch(typeof(PrivateArea), "Awake")]
	internal static class PrivateAreaAwakePatch
	{
		private static void Postfix(PrivateArea __instance)
		{
			ManagedWardRef ward = ManagedWardRef.FromArea(__instance);
			ZDO zdo = ward.Zdo;
			bool matchedByComponent = ward.HasManagedComponent;
			bool matchedByZdo = ward.IsManagedZdo;
			if (!ShouldSkipPlacementGhostAwake(__instance, matchedByComponent, matchedByZdo, zdo) && (matchedByComponent || matchedByZdo))
			{
				ManagedWardIdentity.TryResolve(ward, repairComponent: true, out matchedByComponent, out matchedByZdo);
				ManagedWardInitializationCoordinator.EnsureLocalInitialization(__instance);
			}
		}

		private static bool ShouldSkipPlacementGhostAwake(PrivateArea area, bool matchedByComponent, bool matchedByZdo, ZDO? zdo)
		{
			if (Player.IsPlacementGhost(((Component)area).gameObject))
			{
				return true;
			}
			if (matchedByComponent && !matchedByZdo && zdo == null && ZNetView.m_forceDisableInit)
			{
				return true;
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(PrivateArea), "OnDestroy")]
	internal static class PrivateAreaOnDestroyPatch
	{
		private static void Prefix(PrivateArea __instance)
		{
			ManagedWardLifecycle.NotifyAreaDestroyed(__instance);
		}
	}
	[HarmonyPatch(typeof(PrivateArea), "UpdateStatus")]
	internal static class PrivateAreaUpdateStatusPatch
	{
		private static void Postfix(PrivateArea __instance)
		{
			ManagedWardRef ward = ManagedWardRef.FromArea(__instance);
			bool enabledChanged;
			bool dataRevisionChanged;
			if (ward.IsPlacementGhost || !WardAccess.IsManagedWard(ward, requireEnabled: false))
			{
				WardAccess.UnregisterManagedWard(ward);
				WardRuntimeStateTracker.Forget(__instance);
			}
			else if (WardRuntimeStateTracker.TryConsumeChanges(__instance, out enabledChanged, out dataRevisionChanged))
			{
				bool flag = false;
				bool flag2 = false;
				if (ManagedWardRuntimeContexts.TryGet(__instance, out ManagedWardRuntimeContext context))
				{
					flag = enabledChanged && ManagedWardRuntimeContexts.TryConsumeEnabledFanOutSuppression(__instance, context.ObservedState.Enabled);
					flag2 = dataRevisionChanged && ManagedWardRuntimeContexts.TryConsumeDataRevisionFanOutSuppression(__instance, context.ObservedState.DataRevision);
				}
				if (enabledChanged)
				{
					ManagedWardInteractionRpc.NotifyLocalEnabledStateObserved(__instance);
					WardAccess.RefreshManagedWardState(ward);
				}
				if (dataRevisionChanged)
				{
					WardSettings.ApplyAreaState(ward);
				}
				bool num = enabledChanged && !flag;
				bool flag3 = dataRevisionChanged && !flag2;
				if (num || flag3)
				{
					ManagedWardMapStateService.NotifyWardMutation(__instance);
				}
			}
		}
	}
	[HarmonyPatch(typeof(PrivateArea), "Setup")]
	internal static class PrivateAreaSetupPatch
	{
		private static void Postfix(PrivateArea __instance)
		{
			if (ManagedWardIdentity.TryResolve(ManagedWardRef.FromArea(__instance), repairComponent: true, out var matchedByComponent, out var matchedByZdo))
			{
				ManagedWardLifecycle.NotifyAreaReady(__instance, matchedByComponent, matchedByZdo);
			}
		}
	}
	[HarmonyPatch(typeof(ZNetScene), "CreateObject", new Type[] { typeof(ZDO) })]
	internal static class ZNetSceneCreateObjectManagedWardPatch
	{
		private static void Postfix(ZDO zdo, GameObject __result)
		{
			if (!((Object)(object)__result == (Object)null) && zdo != null && zdo.IsValid())
			{
				PrivateArea val = __result.GetComponent<PrivateArea>() ?? __result.GetComponentInChildren<PrivateArea>();
				if (!((Object)(object)val == (Object)null) && ManagedWardIdentity.TryResolve(val, zdo, repairComponent: true, out var matchedByComponent, out var matchedByZdo))
				{
					ManagedWardInitializationCoordinator.EnsureLocalInitialization(val);
					ManagedWardLifecycle.NotifyAreaReady(val, matchedByComponent, matchedByZdo);
				}
			}
		}
	}
	[HarmonyPatch(typeof(PrivateArea), "ShowAreaMarker")]
	internal static class PrivateAreaShowAreaMarkerPatch
	{
		private static bool Prefix(PrivateArea __instance)
		{
			if (!WardAccess.IsManagedWard(__instance, requireEnabled: false))
			{
				return true;
			}
			if (!WardSettings.ShouldShowAreaMarker(__instance))
			{
				return false;
			}
			WardSettings.ShowManagedAreaMarker(__instance);
			return false;
		}
	}
	internal static class ManagedWardInteractionRpc
	{
		private readonly struct PendingLocalBoolToggleRequest
		{
			internal bool ExpectedValue { get; }

			internal float ExpiresAt { get; }

			internal PendingLocalBoolToggleRequest(bool expectedValue, float expiresAt)
			{
				ExpectedValue = expectedValue;
				ExpiresAt = expiresAt;
			}
		}

		private const string RpcRequestToggleEnabled = "STUWard_RequestToggleEnabled";

		private const string RpcPlayToggleEffect = "STUWard_PlayToggleEffect";

		private static readonly Dictionary<ZDOID, PendingLocalBoolToggleRequest> PendingLocalEnabledToggleRequests = new Dictionary<ZDOID, PendingLocalBoolToggleRequest>();

		private const float PendingLocalToggleTimeoutSeconds = 1.5f;

		internal static void RegisterRoutedRpcs(ZRoutedRpc routedRpc)
		{
			routedRpc.Register<ZPackage>("STUWard_RequestToggleEnabled", (Action<long, ZPackage>)HandleRoutedToggleEnabled);
			routedRpc.Register<ZPackage>("STUWard_PlayToggleEffect", (Action<long, ZPackage>)HandleRoutedPlayToggleEffect);
		}

		internal static bool IsManagedWardForHooks(PrivateArea? area)
		{
			if ((Object)(object)area == (Object)null)
			{
				return false;
			}
			return ManagedWardIdentity.EnsureManagedComponent(area);
		}

		internal static void ResetLocalInteractionState()
		{
			PendingLocalEnabledToggleRequests.Clear();
		}

		internal static bool TryHandleInteract(PrivateArea area, Player player, bool hold, ref bool result)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			result = false;
			if (hold)
			{
				return false;
			}
			if ((int)area.m_ownerFaction != 0)
			{
				return false;
			}
			ZNetView nView = GetNView(area);
			if ((Object)(object)nView == (Object)null || !nView.IsValid())
			{
				return false;
			}
			if (Plugin.IsWardSettingsShortcutDown())
			{
				result = false;
				return false;
			}
			long playerID = player.GetPlayerID();
			if (WardAccess.HasManagedWardTrust(area, playerID) || WardAdminDebugAccess.CanLocallyAttemptAnyWardControl(area, player))
			{
				result = RequestToggleEnabled(area);
			}
			return false;
		}

		internal static string? GetHoverActionLine(PrivateArea area, Player? player)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null || (int)area.m_ownerFaction != 0)
			{
				return null;
			}
			if (WardAccess.HasManagedWardTrust(area, player.GetPlayerID()) || WardAdminDebugAccess.CanLocallyAttemptAnyWardControl(area, player))
			{
				return LocalizeUseAction(area.IsEnabled() ? "$piece_guardstone_deactivate" : "$piece_guardstone_activate", area.IsEnabled() ? "Deactivate" : "Activate");
			}
			return null;
		}

		private static bool RequestToggleEnabled(PrivateArea area)
		{
			//IL_0034: 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_0058: Expected O, but got Unknown
			//IL_005a: 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)
			ZNetView nView = GetNView(area);
			if ((Object)(object)nView == (Object)null || !nView.IsValid())
			{
				return false;
			}
			ZDO zdo = WardPrivateAreaSafeAccess.GetZdo(area);
			if (zdo == null || !zdo.IsValid())
			{
				return false;
			}
			if (IsLocalToggleRequestInFlight(PendingLocalEnabledToggleRequests, zdo.m_uid, area.IsEnabled()))
			{
				return true;
			}
			bool expectedValue = !area.IsEnabled();
			ZPackage val = new ZPackage();
			val.Write(zdo.m_uid);
			if (!WardOwnership.TryInvokeServerRoutedRpc("STUWard_RequestToggleEnabled", val))
			{
				return false;
			}
			PendingLocalEnabledToggleRequests[zdo.m_uid] = new PendingLocalBoolToggleRequest(expectedValue, Time.time + 1.5f);
			return true;
		}

		private static void HandleRoutedToggleEnabled(long sender, ZPackage? request)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			if (TryResolveServerWardRequest(sender, request, out ZDO zdo, out long requesterId) && WardAccess.HasManagedWardTrust(zdo, requesterId) && WardOwnership.TryClaimManagedWardMutationOwnership(zdo))
			{
				bool flag = !zdo.GetBool(ZDOVars.s_enabled, false);
				zdo.Set(ZDOVars.s_enabled, flag);
				WardOwnership.CompleteAuthoritativeManagedWardMutation(zdo);
				SendToggleEffect(sender, zdo.m_uid, flag);
			}
		}

		private static void SendToggleEffect(long receiverUid, ZDOID wardZdoId, bool enabled)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (receiverUid != 0L && !((ZDOID)(ref wardZdoId)).IsNone())
			{
				ZPackage val = new ZPackage();
				val.Write(wardZdoId);
				val.Write(enabled);
				ZRoutedRpc instance = ZRoutedRpc.instance;
				if (instance != null)
				{
					instance.InvokeRoutedRPC(receiverUid, "STUWard_PlayToggleEffect", new object[1] { val });
				}
			}
		}

		private static void HandleRoutedPlayToggleEffect(long sender, ZPackage? response)
		{
			//IL_0021: 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_0083: Unknown result type (might be due to invalid IL or missing references)
			if (!WardOwnership.IsAuthoritativeServerSender(sender) || !TryReadToggleEffect(response, out var wardZdoId, out var enabled))
			{
				return;
			}
			ZNetScene instance = ZNetScene.instance;
			GameObject val = ((instance != null) ? instance.FindInstance(wardZdoId) : null);
			PrivateArea val2 = (((Object)(object)val != (Object)null) ? (val.GetComponent<PrivateArea>() ?? val.GetComponentInChildren<PrivateArea>()) : null);
			if (!((Object)(object)val2 == (Object)null) && WardAccess.IsManagedWard(val2, requireEnabled: false))
			{
				EffectList val3 = (enabled ? val2.m_activateEffect : val2.m_deactivateEffect);
				if (val3 != null)
				{
					Transform transform = ((Component)val2).transform;
					val3.Create(transform.position, transform.rotation, (Transform)null, 1f, -1);
				}
			}
		}

		private static bool TryResolveServerWardRequest(long sender, ZPackage? request, out ZDO zdo, out long requesterId)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			zdo = null;
			requesterId = 0L;
			if (TryReadRoutedWardRequest(request, out var wardZdoId))
			{
				return TryResolveServerWardRequest(sender, wardZdoId, out zdo, out requesterId);
			}
			return false;
		}

		private static bool TryResolveServerWardRequest(long sender, ZDOID wardZdoId, out ZDO zdo, out long requesterId)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			zdo = null;
			requesterId = 0L;
			return WardOwnership.TryResolveAuthoritativeManagedWardRequest(sender, wardZdoId, out zdo, out requesterId);
		}

		private static bool TryReadRoutedWardRequest(ZPackage? request, out ZDOID wardZdoId)
		{
			//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_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_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)
			wardZdoId = ZDOID.None;
			if (request == null)
			{
				return false;
			}
			try
			{
				wardZdoId = request.ReadZDOID();
				return !((ZDOID)(ref wardZdoId)).IsNone();
			}
			catch
			{
				wardZdoId = ZDOID.None;
				return false;
			}
		}

		private static bool TryReadToggleEffect(ZPackage? response, out ZDOID wardZdoId, out bool enabled)
		{
			//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_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			wardZdoId = ZDOID.None;
			enabled = false;
			if (response == null)
			{
				return false;
			}
			try
			{
				wardZdoId = response.ReadZDOID();
				enabled = response.ReadBool();
				return !((ZDOID)(ref wardZdoId)).IsNone();
			}
			catch
			{
				wardZdoId = ZDOID.None;
				enabled = false;
				return false;
			}
		}

		internal static bool TryHandleVanillaToggleEnabled(PrivateArea area, long sender, long claimedPlayerId)
		{
			if (!WardOwnership.CanApplyManagedWardStateLocally(GetNView(area)))
			{
				return false;
			}
			if (!WardOwnership.TryResolveClaimedPlayerIdFromSender(sender, claimedPlayerId, out var playerId))
			{
				return false;
			}
			return ApplyToggleEnabled(area, playerId);
		}

		private static bool ApplyToggleEnabled(PrivateArea area, long requesterId)
		{
			if (!WardAccess.HasManagedWardTrust(area, requesterId))
			{
				return false;
			}
			if (!WardOwnership.TryClaimManagedWardMutationOwnership(area))
			{
				return false;
			}
			bool flag = !area.IsEnabled();
			ManagedWardRuntimeContexts.ArmNextEnabledFanOutSuppression(area, flag);
			ManagedWardRuntimeContexts.ArmNextDataRevisionFanOutSuppression(area);
			area.SetEnabled(flag);
			return true;
		}

		private static ZNetView? GetNView(PrivateArea area)
		{
			return WardPrivateAreaSafeAccess.GetNView(area);
		}

		internal static void NotifyLocalEnabledStateObserved(PrivateArea area)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			ZDO zdo = WardPrivateAreaSafeAccess.GetZdo(area);
			if (zdo != null && zdo.IsValid())
			{
				PendingLocalEnabledToggleRequests.Remove(zdo.m_uid);
			}
		}

		private static bool IsLocalToggleRequestInFlight(Dictionary<ZDOID, PendingLocalBoolToggleRequest> pendingRequests, ZDOID wardZdoId, bool currentValue)
		{
			//IL_0001: 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)
			if (!pendingRequests.TryGetValue(wardZdoId, out var value))
			{
				return false;
			}
			if (Time.time >= value.ExpiresAt || currentValue == value.ExpectedValue)
			{
				pendingRequests.Remove(wardZdoId);
				return false;
			}
			return true;
		}

		private static string LocalizeUseAction(string token, string fallback)
		{
			if (Localization.instance == null)
			{
				return "[E] " + fallback;
			}
			return Localization.instance.Localize("[<color=yellow><b>$KEY_Use</b></color>] " + token);
		}
	}
	internal static class ManagedWardHoverTextService
	{
		private readonly struct HoverTextLine
		{
			internal int Start { get; }

			internal int Length { get; }

			internal string? Text { get; }

			internal bool IsInserted => Text != null;

			internal HoverTextLine(int start, int length)
			{
				Start = start;
				Length = length;
				Text = null;
			}

			internal HoverTextLine(string text)
			{
				Start = 0;
				Length = 0;
				Text = text;
			}
		}

		internal static bool TryRewriteHoverText(PrivateArea? area, string originalText, out string rewrittenText)
		{
			rewrittenText = originalText;
			if ((Object)(object)area == (Object)null || !WardAccess.IsManagedWard(area, requireEnabled: false) || string.IsNullOrEmpty(originalText))
			{
				return false;
			}
			Player localPlayer = Player.m_localPlayer;
			ZDO? zdo = WardPrivateAreaSafeAccess.GetZdo(area);
			uint dataRevision = ((zdo != null) ? zdo.DataRevision : 0u);
			long playerId = (((Object)(object)localPlayer != (Object)null) ? localPlayer.GetPlayerID() : 0);
			string text = GuildsCompat.GetWardGuildName(area) ?? string.Empty;
			string text2 = (string.IsNullOrWhiteSpace(text) ? null : WardLocalization.LocalizeFormat("$stuw_ui_guild", "Guild: {0}", text));
			bool flag = WardAccess.CanConfigureWard(area, localPlayer);
			bool flag2 = WardAdminDebugAccess.CanLocallyAttemptAnyWardControl(area, localPlayer);
			string hoverActionLine = ManagedWardInteractionRpc.GetHoverActionLine(area, localPlayer);
			string text3 = null;
			bool flag3 = Plugin.HasWardSettingsShortcutBinding();
			string text4 = (flag3 ? Plugin.GetWardSettingsShortcutLabel() : string.Empty);
			if ((Object)(object)localPlayer != (Object)null && flag3 && (flag || flag2))
			{
				text3 = WardLocalization.LocalizeFormat("$stuw_hover_settings", "[<color=yellow><b>{0}</b></color>] Ward settings", text4);
			}
			bool flag4 = originalText[0] == '[' || originalText.IndexOf("\n[", StringComparison.Ordinal) >= 0;
			if (text2 == null && hoverActionLine == null && text3 == null && !flag4)
			{
				ManagedWardRuntimeContexts.ClearHoverText(area);
				return false;
			}
			ManagedWardHoverTextCacheEntry other = new ManagedWardHoverTextCacheEntry(dataRevision, originalText, playerId, flag, flag2, flag3, text4, text, string.Empty);
			if (ManagedWardRuntimeContexts.TryGet(area, out ManagedWardRuntimeContext context) && context.HasHoverText && context.HoverText.Matches(other))
			{
				rewrittenText = context.HoverText.FinalText;
				return true;
			}
			int actionLineIndex;
			List<HoverTextLine> list = CollectHoverTextLines(originalText, out actionLineIndex);
			if (list.Count < 2)
			{
				return false;
			}
			if (actionLineIndex >= 0)
			{
				list.RemoveAt(actionLineIndex);
			}
			if (text2 != null)
			{
				list.Insert(Mathf.Min(2, list.Count), new HoverTextLine(text2));
			}
			if (hoverActionLine != null)
			{
				int index = ((list.Count > 1) ? (list.Count - 1) : list.Count);
				list.Insert(index, new HoverTextLine(hoverActionLine));
			}
			if (text3 != null && list.Count >= 3)
			{
				list.Insert(list.Count - 1, new HoverTextLine(text3));
			}
			rewrittenText = BuildHoverText(originalText, list, text2, hoverActionLine, text3);
			ManagedWardRuntimeContext orCreate = ManagedWardRuntimeContexts.GetOrCreate(area);
			orCreate.HoverText = other.WithFinalText(rewrittenText);
			orCreate.HasHoverText = true;
			return true;
		}

		private static List<HoverTextLine> CollectHoverTextLines(string text, out int actionLineIndex)
		{
			List<HoverTextLine> list = new List<HoverTextLine>(4);
			actionLineIndex = -1;
			int num = 0;
			while (num <= text.Length)
			{
				int num2 = text.IndexOf('\n', num);
				if (num2 < 0)
				{
					num2 = text.Length;
				}
				int num3 = num2 - num;
				if (actionLineIndex < 0 && num3 > 0 && text[num] == '[')
				{
					actionLineIndex = list.Count;
				}
				list.Add(new HoverTextLine(num, num3));
				if (num2 >= text.Length)
				{
					break;
				}
				num = num2 + 1;
			}
			return list;
		}

		private static string BuildHoverText(string originalText, List<HoverTextLine> lines, string? guildLine, string? toggleLine, string? settingsLine)
		{
			StringBuilder stringBuilder = new StringBuilder(originalText.Length + (guildLine?.Length ?? 0) + (toggleLine?.Length ?? 0) + (settingsLine?.Length ?? 0) + 4);
			for (int i = 0; i < lines.Count; i++)
			{
				if (i > 0)
				{
					stringBuilder.Append('\n');
				}
				HoverTextLine hoverTextLine = lines[i];
				if (hoverTextLine.IsInserted)
				{
					stringBuilder.Append(hoverTextLine.Text);
				}
				else
				{
					stringBuilder.Append(originalText, hoverTextLine.Start, hoverTextLine.Length);
				}
			}
			return stringBuilder.ToString();
		}
	}
	[HarmonyPatch(typeof(PrivateArea), "GetHoverText")]
	internal static class PrivateAreaGetHoverTextPatch
	{
		private static void Postfix(PrivateArea __instance, ref string __result)
		{
			if (ManagedWardHoverTextService.TryRewriteHoverText(__instance, __result, out string rewrittenText))
			{
				__result = rewrittenText;
			}
		}
	}
	[HarmonyPatch(typeof(PrivateArea), "Interact")]
	internal static class PrivateAreaInteractAdminDebugPatch
	{
		private static bool Prefix(PrivateArea __instance, Humanoid human, bool hold, bool alt, ref bool __result)
		{
			Player val = (Player)(object)((human is Player) ? human : null);
			if (val == null || (Object)(object)val != (Object)(object)Player.m_localPlayer)
			{
				return true;
			}
			if (!WardAccess.IsManagedWard(__instance, requireEnabled: false))
			{
				return true;
			}
			return ManagedWardInteractionRpc.TryHandleInteract(__instance, val, hold, ref __result);
		}
	}
	[HarmonyPatch(typeof(PrivateArea), "RPC_ToggleEnabled")]
	internal static class PrivateAreaRpcToggleEnabledAdminDebugPatch
	{
		private static bool Prefix(PrivateArea __instance, long uid, long playerID)
		{
			if (!ManagedWardInteractionRpc.IsManagedWardForHooks(__instance))
			{
				return true;
			}
			ManagedWardInteractionRpc.TryHandleVanillaToggleEnabled(__instance, uid, playerID);
			return false;
		}
	}
	[HarmonyPatch(typeof(PrivateArea), "RPC_TogglePermitted")]
	internal static class PrivateAreaRpcTogglePermittedManagedPatch
	{
		private static bool Prefix(PrivateArea __instance)
		{
			if (!ManagedWardInteractionRpc.IsManagedWardForHooks(__instance))
			{
				return true;
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(PrivateArea), "HideMarker")]
	internal static class PrivateAreaHideMarkerPatch
	{
		private static bool Prefix(PrivateArea __instance)
		{
			if (!WardAccess.IsManagedWard(__instance, requireEnabled: false))
			{
				return true;
			}
			return !WardSettings.ShouldShowAreaMarker(__instance);
		}
	}
	[HarmonyPatch(typeof(CircleProjector), "CreateSegments")]
	internal static class CircleProjectorCreateSegmentsPatch
	{
		private static void Prefix(CircleProjector __instance)
		{
			PrivateArea componentInParent = ((Component)__instance).GetComponentInParent<PrivateArea>();
			if (!((Object)(object)componentInParent == (Object)null) && !((Object)(object)componentInParent.m_areaMarker != (Object)(object)__instance) && WardAccess.IsManagedWard(componentInParent, requireEnabled: false))
			{
				__instance.m_nrOfSegments = 36;
			}
		}

		private static void Postfix(CircleProjector __instance)
		{
			PrivateArea componentInParent = ((Component)__instance).GetComponentInParent<PrivateArea>();
			ManagedWardRef ward = ManagedWardRef.FromArea(componentInParent);
			if (!((Object)(object)componentInParent == (Object)null) && !((Object)(object)componentInParent.m_areaMarker != (Object)(object)__instance) && WardAccess.IsManagedWard(ward, requireEnabled: false))
			{
				ManagedWardInitializationCoordinator.EnsureLocalInitialization(componentInParent);
				WardSettings.ApplyAreaState(ward);
			}
		}
	}
	[HarmonyPatch(typeof(PrivateArea), "RPC_FlashShield")]
	internal static class PrivateAreaRpcFlashShieldVolumePatch
	{
		private static bool Prefix(PrivateArea __instance)
		{
			return WardSettings.HandleManagedFlashEffect(__instance);
		}
	}
	[HarmonyPatch(typeof(Door), "RPC_UseDoor")]
	internal static class DoorRpcUseDoorPatch
	{
		private sealed class ScheduledDoorClose
		{
			internal int Generation { get; }

			internal Coroutine Coroutine { get; }

			internal ScheduledDoorClose(int generation, Coroutine coroutine)
			{
				Generation = generation;
				Coroutine = coroutine;
			}
		}

		private const float AutoCloseDelaySeconds = 5f;

		private static readonly Dictionary<int, ScheduledDoorClose> DoorCloseCoroutines = new Dictionary<int, ScheduledDoorClose>();

		private static int _nextScheduleGeneration;

		private static void Prefix(Door __instance, out int __state)
		{
			__state = GetDoorState(__instance);
		}

		private static void Postfix(Door __instance, int __state)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			int doorState = GetDoorState(__instance);
			if (__state != 0 && doorState == 0)
			{
				CancelDoorAutoClose(__instance);
			}
			else if (__state == 0 && doorState != 0 && doorState != __state)
			{
				if (!CanAutoClose(__instance) || !WardSettings.IsDoorAutoCloseEnabledAt(((Component)__instance).transform.position))
				{
					CancelDoorAutoClose(__instance);
				}
				else
				{
					ScheduleDoorAutoClose(__instance);
				}
			}
		}

		internal static void Reset()
		{
			Plugin instance = Plugin.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				foreach (ScheduledDoorClose value in DoorCloseCoroutines.Values)
				{
					((MonoBehaviour)instance).StopCoroutine(value.Coroutine);
				}
			}
			DoorCloseCoroutines.Clear();
			_nextScheduleGeneration = 0;
		}

		private static void ScheduleDoorAutoClose(Door? door)
		{
			if ((Object)(object)door == (Object)null || !CanAutoClose(door))
			{
				return;
			}
			ZNetView validNView = GetValidNView(door);
			Plugin instance = Plugin.Instance;
			if (!((Object)(object)validNView == (Object)null) && validNView.IsOwner() && !((Object)(object)instance == (Object)null))
			{
				int instanceID = ((Object)door).GetInstanceID();
				if (DoorCloseCoroutines.TryGetValue(instanceID, out ScheduledDoorClose value))
				{
					((MonoBehaviour)instance).StopCoroutine(value.Coroutine);
				}
				int generation = AllocateScheduleGeneration();
				Coroutine coroutine = ((MonoBehaviour)instance).StartCoroutine(CloseDoorAfterDelay(door, instanceID, generation));
				DoorCloseCoroutines[instanceID] = new ScheduledDoorClose(generation, coroutine);
			}
		}

		private static void CancelDoorAutoClose(Door? door)
		{
			if ((Object)(object)door == (Object)null)
			{
				return;
			}
			int instanceID = ((Object)door).GetInstanceID();
			if (DoorCloseCoroutines.TryGetValue(instanceID, out ScheduledDoorClose value))
			{
				DoorCloseCoroutines.Remove(instanceID);
				Plugin instance = Plugin.Instance;
				if ((Object)(object)instance != (Object)null)
				{
					((MonoBehaviour)instance).StopCoroutine(value.Coroutine);
				}
			}
		}

		private static IEnumerator CloseDoorAfterDelay(Door door, int key, int generation)
		{
			yield return (object)new WaitForSeconds(5f);
			if (!DoorCloseCoroutines.TryGetValue(key, out ScheduledDoorClose value) || value.Generation != generation)
			{
				yield break;
			}
			DoorCloseCoroutines.Remove(key);
			if (!CanAutoClose(door))
			{
				yield break;
			}
			ZNetView validNView = GetValidNView(door);
			if (!((Object)(object)validNView == (Object)null) && validNView.IsOwner() && WardSettings.IsDoorAutoCloseEnabledAt(((Component)door).transform.position))
			{
				ZDO zDO = validNView.GetZDO();
				if (zDO != null && zDO.GetInt(ZDOVars.s_state, 0) != 0)
				{
					validNView.InvokeRPC("UseDoor", new object[1] { true });
				}
			}
		}

		private static ZNetView? GetValidNView(Door? door)
		{
			if ((Object)(object)door == (Object)null)
			{
				return null;
			}
			ZNetView val = (((Object)(object)door.m_nview != (Object)null) ? door.m_nview : ((Component)door).GetComponent<ZNetView>());
			if (!((Object)(object)val != (Object)null) || !val.IsValid())
			{
				return null;
			}
			return val;
		}

		private static int GetDoorState(Door? door)
		{
			ZNetView? validNView = GetValidNView(door);
			int? obj;
			if (validNView == null)
			{
				obj = null;
			}
			else
			{
				ZDO zDO = validNView.GetZDO();
				obj = ((zDO != null) ? new int?(zDO.GetInt(ZDOVars.s_state, 0)) : ((int?)null));
			}
			int? num = obj;
			return num.GetValueOrDefault();
		}

		private static bool CanAutoClose(Door? door)
		{
			if ((Object)(object)door != (Object)null && !door.m_canNotBeClosed)
			{
				return (Object)(object)door.m_keyItem == (Object)null;
			}
			return false;
		}

		private static int AllocateScheduleGeneration()
		{
			if (_nextScheduleGeneration == int.MaxValue)
			{
				_nextScheduleGeneration = 0;
			}
			return ++_nextScheduleGeneration;
		}
	}
	[HarmonyPatch(typeof(PrivateArea), "SetEnabled")]
	internal static class PrivateAreaSetEnabledWardMinimapVisibilityPatch
	{
		private static void Postfix(PrivateArea __instance)
		{
			if (ManagedWardInteractionRpc.IsManagedWardForHooks(__instance))
			{
				ManagedWardRef ward = ManagedWardRef.FromArea(__instance);
				ManagedWardMapStateService.NotifyWardMutation(__instance);
				WardOwnership.ForceSyncManagedWardZdoToServer(ward);
			}
		}
	}
	internal static class GuildsSaveGuildPatch
	{
		internal static void Postfix(object[] __args)
		{
			if (GuildsCompat.IsGuildHooksActive() && __args.Length != 0)
			{
				GuildsCompat.HandleGuildSaved(__args[0]);
			}
		}
	}
}
namespace ServerSync
{
	[PublicAPI]
	internal abstract class OwnConfigEntryBase
	{
		public object? LocalBaseValue;

		public bool SynchronizedConfig = true;

		public abstract ConfigEntryBase BaseConfig { get; }
	}
	[PublicAPI]
	internal class SyncedConfigEntry<T>(ConfigEntry<T> sourceConfig) : OwnConfigEntryBase()
	{
		public readonly ConfigEntry<T> SourceConfig = sourceConfig;

		public override ConfigEntryBase BaseConfig => (ConfigEntryBase)(object)SourceConfig;

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

		public void AssignLocalValue(T value)
		{
			if (LocalBaseValue == null)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	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)
			{
				ZNetPeer peer;
				if (__instance.IsServer())
				{
					object obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
					peer = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
					if (peer == null)
					{
						SendBufferedData();
					}
					else
					{
						((MonoBehaviour)__instance).StartCoroutine(sendAsync());
					}
				}
				void SendBufferedData()
				{
					if (rpc.GetSocket() is BufferingSocket bufferingSocket)
					{
						AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc, bufferingSocket.Original);
						object? obj2 = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
						ZNetPeer val = (ZNetPeer)((obj2 is ZNetPeer) ? obj2 : null);
						if (val != null)
						{
							AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket").SetValue(val, bufferingSocket.Original);
						}
					}
					BufferingSocket bufferingSocket2 = __state[Assembly.GetExecutingAssembly()];
					bufferingSocket2.finished = true;
					for (int i = 0; i < bufferingSocket2.Package.Count; i++)
					{
						if (i == bufferingSocket2.versionMatchQueued)
						{
							bufferingSocket2.Original.VersionMatch();
						}
						bufferingSocket2.Original.Send(bufferingSocket2.Package[i]);
					}
					if (bufferingSocket2.Package.Count == bufferingSocket2.versionMatchQueued)
					{
						bufferingSocket2.Original.VersionMatch();
					}
				}
				IEnumerator sendAsync()
				{
					foreach (ConfigSync configSync in configSyncs)
					{
						List<PackageEntry> entries = new List<PackageEntry>();
						if (configSync.CurrentVersion != null)
						{
							entries.Add(new PackageEntry
							{
								section = "Internal",
								key = "serverversion",
								type = typeof(string),
								value = configSync.CurrentVersion
							});
						}
						MethodInfo listContainsId = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
						SyncedList adminList = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
						entries.Add(new PackageEntry
						{
							section = "Internal",
							key = "lockexempt",
							type = typeof(bool),
							value = (((object)listContainsId == null) ? ((object)adminList.Contains(rpc.GetSocket().GetHostName())) : listContainsId.Invoke(ZNet.instance, new object[2]
							{
								adminList,
								rpc.GetSocket().GetHostName()
							}))
						});
						ZPackage package = ConfigsToPackage(configSync.allConfigs.Select((OwnConfigEntryBase c) => c.BaseConfig), configSync.allCustomValues, entries, partial: false);
						yield return ((MonoBehaviour)__instance).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 == true;
				}
				if (!num)
				{
					goto IL_0052;
				}
				int result = ((!lockExempt) ? 1 : 0);
				goto IL_0053;
				IL_0052:
				result = 0;
				goto IL_0053;
				IL_0053:
				return (byte)result != 0;
			}
			set
			{
				forceConfigLocking = value;
			}
		}

		public bool IsAdmin => lockExempt || isSourceOfTruth;

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

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

		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)
		{
			OwnConfigEntryBase ownConfigEntryBase = configData((ConfigEntryBase)(object)configEntry);
			SyncedConfigEntry<T> syncedEntry = ownConfigEntryBase as SyncedConfigEntry<T>;
			if (syncedEntry == null)
			{
				syncedEntry = new SyncedConfigEntry<T>(configEntry);
				AccessTools.DeclaredField(typeof(ConfigDescription), "<Tags>k__BackingField").SetValue(((ConfigEntryBase)configEntry).Description, new object[1]
				{
					new ConfigurationManagerAttributes()
				}.Concat(((ConfigEntryBase)configEntry).Description.Tags ?? Array.Empty<object>()).Concat(new SyncedConfigEntry<T>[1] { syncedEntry }).ToArray());
				configEntry.SettingChanged += delegate
				{
					if (!ProcessingServerUpdate && syncedEntry.SynchronizedConfig)
					{
						Broadcast(ZRoutedRpc.Everybody, (ConfigEntryBase)configEntry);
					}
				};
				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)
		{
			if (allCustomValues.Select((CustomSyncedValueBase v) => v.Identifier).Concat(new string[1] { "serverversion" }).Contains(customValue.Identifier))
			{
				throw new Exception("Cannot have multiple settings with the same name or with a reserved name (serverversion)");
			}
			allCustomValues.Add(customValue);
			allCustomValues = new HashSet<CustomSyncedValueBase>(allCustomValues.OrderByDescending((CustomSyncedValueBase v) => v.Priority));
			customValue.ValueChanged += delegate
			{
				if (!ProcessingServerUpdate)
				{
					Broadcast(ZRoutedRpc.Everybody, customValue);
				}
			};
		}

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

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

		private bool HandleConfigSyncRPC(long sender, ZPackage package, bool clientUpdate)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Expected O, but got Unknown
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Expected O, but got Unknown
			try
			{
				if (isServer && IsLocked)
				{
					ZRpc? currentRpc = SnatchCurrentlyHandlingRPC.currentRpc;
					object obj;
					if (currentRpc == null)
					{
						obj = null;
					}
					else
					{
						ISocket socket = currentRpc.GetSocket();
						obj = ((socket != null) ? socket.GetHostName() : null);
					}
					string text = (string)obj;
					if (text != null)
					{
						MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
						SyncedList val = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
						if (!(((object)methodInfo == null) ? val.Contains(text) : ((bool)methodInfo.Invoke(ZNet.instance, new object[2] { val, text }))))
						{
							return false;
						}
					}
				}
				cacheExpirations.RemoveAll(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 & 2) != 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 & 4) != 0)
				{
					byte[] buffer = package.ReadByteArray();
					MemoryStream stream = new MemoryStream(buffer);
					MemoryStream memoryStream = new MemoryStream();
					using (DeflateStream deflateStream = new DeflateStream(stream, CompressionMode.Decompress))
					{
						deflateStream.CopyTo(memoryStream);
					}
					package = new ZPackage(memoryStream.ToArray());
					b = package.ReadByte();
				}
				if ((b & 1) == 0)
				{
					resetConfigsFromServer();
				}
				ParsedConfigs parsedConfigs = ReadConfigsFromPackage(package);
				ConfigFile 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 num2 = 0; num2 < num; num2++)
			{
				string text = package.ReadString();
				string text2 = package.ReadString();
				string text3 = package.ReadString();
				Type type = Type.GetType(text3);
				if (text3 == "" || type != null)
				{
					object obj;
					try
					{
						obj = ((text3 == "") ? null : ReadValueWithTypeFromZPackage(package, type));
					}
					catch (InvalidDeserializationTypeException ex)
					{
						Debug.LogWarning((object)("Got unexpected struct internal type " + ex.received + " for field " + ex.field + " struct " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + ex.expected));
						continue;
					}
					OwnConfigEntryBase value2;
					if (text == "Internal")
					{
						CustomSyncedValueBase value;
						if (text2 == "serverversion")
						{
							if (obj?.ToString() != CurrentVersion)
							{
								Debug.LogWarning((object)("Received server version is not equal: server version = " + (obj?.ToString() ?? "null") + "; local version = " + (CurrentVersion ?? "unknown")));
							}
						}
						else if (text2 == "lockexempt")
						{
							if (obj is bool flag)
							{
								lockExempt = flag;
							}
						}
						else if (dictionary2.TryGetValue(text2, out value))
						{
							if ((text3 == "" && (!value.Type.IsValueType || Nullable.GetUnderlyingType(value.Type) != null)) || GetZPackageTypeString(value.Type) == text3)
							{
								parsedConfigs.customValues[value] = obj;
								continue;
							}
							Debug.LogWarning((object)("Got unexpected type " + text3 + " for internal value " + text2 + " for mod " + (DisplayName ?? Name) + ", expecting " + value.Type.AssemblyQualifiedName));
						}
					}
					else if (dictionary.TryGetValue(text + "_" + text2, out value2))
					{
						Type type2 = configType(value2.BaseConfig);
						if ((text3 == "" && (!type2.IsValueType || Nullable.GetUnderlyingType(type2) != null)) || GetZPackageTypeString(type2) == text3)
						{
							parsedConfigs.configValues[value2] = obj;
							continue;
						}
						Debug.LogWarning((object)("Got unexpected type " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + type2.AssemblyQualifiedName));
					}
					else
					{
						Debug.LogWarning((object)("Received unknown config entry " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ". This may happen if client and server versions of the mod do not match."));
					}
					continue;
				}
				Debug.LogWarning((object)("Got invalid type " + text3 + ", abort reading of received configs"));
				return new ParsedConfigs();
			}
			return parsedConfigs;
		}

		private static bool isWritableConfig(OwnConfigEntryBase config)
		{
			ConfigSync configSync = configSyncs.FirstOrDefault((ConfigSync cs) => cs.allConfigs.Contains(config));
			if (configSync == null)
			{
				return true;
			}
			return configSync.IsSourceOfTruth || !config.SynchronizedConfig || config.LocalBaseValue == null || (!configSync.IsLocked && (config != configSync.lockedConfig || lockExempt));
		}

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

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

		private IEnumerator sendZPackage(long target, ZPackage package)
		{
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				return Enumerable.Empty<object>().GetEnumerator();
			}
			List<ZNetPeer> list = (List<ZNetPeer>)AccessTools.DeclaredField(typeof(ZRoutedRpc), "m_peers").GetValue(ZRoutedRpc.instance);
			if (target != ZRoutedRpc.Everybody)
			{
				list = list.Where((ZNetPeer p) => p.m_uid == target).ToList();
			}
			return sendZPackage(list, package);
		}

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

		private void Broadcast(long target, params ConfigEntryBase[] configs)
		{
			if (!IsLocked || isServer)
			{
				ZPackage package = ConfigsToPackage(configs);
				ZNet instance = 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)
		{
			return versionChecks.Where((VersionCheck check) => check.ModRequired && !check.ValidatedClients.Contains(rpc)).ToArray();
		}

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

		private static void DisconnectClient(ZRpc rpc)
		{
			rpc.Invoke("Error", new object[1] { 3 });
		}

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

		private static void CheckVersion(ZRpc rpc, ZPackage pkg, 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]
	[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)
		{
			return type.GetProperties(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public).FirstOrDefault((PropertyInfo p) => p.Name == name);
		}

		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)
		{
			return type.GetRuntimeMethods().FirstOrDefault((MethodInfo m) => !m.IsPublic && m.IsStatic && m.Name.Equals(name)) ?? throw new MissingMethodException("Expected to find a method named '" + name + "' in '" + type.FullName + "'.");
		}

		public static MethodInfo? GetPublicStaticMethod(this Type type, string name, params Type[] parameterTypes)
		{
			return type.GetRuntimeMethods().FirstOrDefault(delegate(MethodInfo m)
			{
				if (m.IsPublic && m.IsStatic && m.Name.Equals(name))
				{
					ParameterInfo[] parameters = m.GetParameters();
					if (parameters.Length == parameterTypes.Length)
					{
						return parameters.Zip(parameterTypes, (ParameterInfo pi, Type pt) => pi.ParameterType == pt).All((bool r) => r);
					}
					return false;
				}
				return false;
			});
		}

		public static MethodInfo? GetPublicInstanceMethod(this Type type, string name)
		{
			return type.GetRuntimeMethods().FirstOrDefault((MethodInfo m) => m.IsPublic && !m.IsStatic && m.Name.Equals(name));
		}

		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)
		{
			if (typeConverter == null)
			{
				throw new ArgumentNullException("typeConverter");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateRegistrationLocationSelector(typeConverter.GetType(), (Nothing _) => typeConverter));
			return Self;
		}

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

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

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

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

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

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

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

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

		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)
		{
			if (objectFactory == null)
			{
				throw new ArgumentNullException("objectFactory");
			}
			this.objectFactory = new Lazy<IObjectFactory>(() => objectFactory, isThreadSafe: true);
			return this;
		}

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

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

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

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

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

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

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

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

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

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

		public DeserializerBuilder 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)
		{
			return registrations.InReverseOrder.Aggregate(innerComponent, (TComponent inner, Func<TArgument, TComponent> factory) => factory(argumentBuilder(inner)));
		}

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

		public static List<TComponent> BuildComponentList<TArgument, TComponent>(this LazyComponentRegistrationList<TArgument, TComponent> registrations, TArgument argument)
		{
			return registrations.Select((Func<TArgument, TComponent> factory) => factory(argument)).ToList();
		}
	}
	[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)
			{
				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, emitter, NestedObjectSerializer);
				void NestedObjectSerializer(object? v, Type? t)
				{
					SerializeValue(emitter, v, t);
				}
			}
		}

		private ObjectGraphTraversalStrategyFactory objectGraphTraversalStrategyFactory;

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

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

		private readonly LazyComponentRegistrationList<IEventEmitter, IEventEmitter> eventEmitterFactories;

		private readonly 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
		{
			return WithEventEmitter((IEventEmitter e, ITypeInspector _) => eventEmitterFactory(e), where);
		}

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

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

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

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

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

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

		public SerializerBuilder EnsureRoundtrip()
		{
			objectGraphTraversalStrategyFactory = (ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion) => new RoundtripObjectGraphTraversalStrategy(typeConverters, typeInspector, typeResolver, maximumRecursion, namingConvention, settings, objectFactory);
			WithEventEmitter((IEventEmitter inner) => new TypeAssigningEventEmitter(inner, 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>
		{
			if (objectGraphVisitor == null)
			{
				throw new ArgumentNullException("objectGraphVisitor");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IEnumerable<IYamlTypeConverter> _) => objectGraphVisitor));
			return this;
		}

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

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

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(WrapperFactory<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<Nothing> wrapped, IEnumerable<IYamlTypeConverter> typeConverters) => objectGraphVisitorFactory(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>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory(args)));
			return this;
		}

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

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

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

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

		public ISerializer Build()
		{
			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)
		{
			if (typeConverter == null)
			{
				throw new ArgumentNullException("typeConverter");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateRegistrationLocationSelector(typeConverter.GetType(), (Nothing _) => typeConverter));
			return Self;
		}

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

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

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

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

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

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

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

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

		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)
		{
			if (nodeDeserializer == null)
			{
				throw new ArgumentNullException("nodeDeserializer");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateRegistrationLocationSelector(nodeDeserializer.GetType(), (Nothing _) => nodeDeserializer));
			return this;
		}

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

		public StaticDeserializerBuilder 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)
		{
			if (nodeTypeResolver == null)
			{
				throw new ArgumentNullException("nodeTypeResolver");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateRegistrationLocationSelector(nodeTypeResolver.GetType(), (Nothing _) => nodeTypeResolver));
			return this;
		}

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

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

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

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

		public StaticDeserializerBuilder WithTypeMapping<TInterface, TConcrete>() where TConcrete : TInterface
		{
			Type typeFromHandle = typeof(TInterface);
			Type typeFromHandle2 = typeof(TConcrete);
			if (!typeFromHandle.IsAssignableFrom(typeFromHandle2))
			{
				throw new InvalidOperationException("The type '" + typeFromHandle2.Name + "' does not implement interface '" + typeFromHandle.Name + "'.");
			}
			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)
			{
				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, emitter, NestedObjectSerializer);
				void NestedObjectSerializer(object? v, Type? t)
				{
					SerializeValue(emitter, v, t);
				}
			}
		}

		private readonly StaticContext context;

		private readonly StaticObjectFactory factory;

		private ObjectGraphTraversalStrategyFactory objectGraphTraversalStrategyFactory;

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

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

		private readonly LazyComponentRegistrationList<IEventEmitter, IEventEmitter> eventEmitterFactories;

		private readonly 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
		{
			return WithEventEmitter((IEventEmitter e, ITypeInspector _) => eventEmitterFactory(e), where);
		}

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

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

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

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

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

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

		public StaticSerializerBuilder EnsureRoundtrip()
		{
			objectGraphTraversalStrategyFactory = (ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion) => new RoundtripObjectGraphTraversalStrategy(typeConverters, typeInspector, typeResolver, maximumRecursion, namingConvention, settings, factory);
			WithEventEmitter((IEventEmitter inner) => new TypeAssigningEventEmitter(inner, 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>
		{
			if (objectGraphVisitor == null)
			{
				throw new ArgumentNullException("objectGraphVisitor");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IEnumerable<IYamlTypeConverter> _) => objectGraphVisitor));
			return this;
		}

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

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

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(WrapperFactory<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<Nothing> wrapped, IEnumerable<IYamlTypeConverter> typeConverters) => objectGraphVisitorFactory(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>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory(args)));
			return this;
		}

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

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

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

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

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

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

		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)
		{
			IEnumerable<IPropertyDescriptor> enumerable = innerTypeDescriptor.GetProperties(type, container);
			if (overrides != null)
			{
				enumerable = enumerable.Select((Func<IPropertyDescriptor, IPropertyDescriptor>)((IPropertyDescriptor p) => new OverridePropertyDescriptor(p, overrides, type)));
			}
			return enumerable;
		}
	}
	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/*cast due to .constrained prefix*/).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;
						throw new AnchorNotFoundException(alias.Start, alias.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))
				{
					throw new AnchorNotFoundException(@event.Start, @event.End, $"Alias ${@event.Value} cannot precede anchor declaration");
				}
				if (!value.HasValue)
				{
					return value;
				}
				return value.Value;
			}
			AnchorName anchorName = AnchorName.Empty;
			if (parser.Accept<NodeEvent>(out var event2) && !event2.Anchor.IsEmpty)
			{
				anchorName = event2.Anchor;
				AliasState 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)
		{
			parser.Accept<NodeEvent>(out var @event);
			Type typeFromEvent = GetTypeFromEvent(@event, expectedType);
			ObjectDeserializer rootDeserializer = (Type x) => DeserializeValue(parser, x, state, nestedObjectDeserializer);
			try
			{
				foreach (INodeDeserializer deserializer in deserializers)
				{
					if (deserializer.Deserialize(parser, typeFromEvent, (IParser r, Type t) => nestedObjectDeserializer.DeserializeValue(r, t, state, nestedObjectDeserializer), out object value, rootDeserializer))
					{
						return typeConverter.ChangeType(value, expectedType, enumNamingConvention, typeInspector);
					}
				}
			}
			catch (YamlException)
			{
				throw;
			}
			catch (Exception innerException)
			{
				throw new YamlException(@event?.Start ?? Mark.Empty, @event?.End ?? Mark.Empty, "Exception during deserialization", innerException);
			}
			throw new YamlException(@event?.Start ?? Mark.Empty, @event?.End ?? Mark.Empty, "No node deserializer was able to deserialize the node into type " + expectedType.AssemblyQualifiedName);
		}

		private Type GetTypeFromEvent(NodeEvent? nodeEvent, Type currentType)
		{
			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)
		{
			str = char.ToLower(str[0], CultureInfo.InvariantCulture) + str.Substring(1);
			str = Regex.Replace(str.ToCamelCase(), "(?<char>[A-Z])", (Match match) => separator + 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 (HasMatch: true, TypeConverter: yamlTypeConverter);
				}
			}
			return (HasMatch: false, TypeConverter: 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)
		{
			return typeInspectors.SelectMany((ITypeInspector i) => i.GetProperties(type, container));
		}
	}
	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)
		{
			IEnumerable<IPropertyDescriptor> enumerable = ((!caseInsensitivePropertyMatching) ? (from p in GetProperties(type, container)
				where p.Name == name
				select p) : (from p in GetProperties(type, container)
				where p.Name.Equals(name, StringComparison.OrdinalIgnoreCase)
				select p));
			using IEnumerator<IPropertyDescriptor> enumerator = enumerable.GetEnumerator();
			if (!enumerator.MoveNext())
			{
				if (ignoreUnmatched)
				{
					return null;
				}
				throw new SerializationException("Property '" + name + "' not found on type '" + type.FullName + "'.");
			}
			IPropertyDescriptor current = enumerator.Current;
			if (enumerator.MoveNext())
			{
				throw new SerializationException("Multiple properties with the name/alias '" + name + "' already exists on type '" + type.FullName + "', maybe you're misusing YamlAlias or maybe you are using the wrong naming convention? The matching properties are: " + string.Join(", ", enumerable.Select((IPropertyDescriptor p) => p.Name).ToArray()));
			}
			return current;
		}
	}
	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) != DefaultValuesHandling.Preserve && value.Value == null)
			{
				return false;
			}
			if ((defaultValuesHandling & DefaultValuesHandling.OmitEmptyCollections) != DefaultValuesHandling.Preserve && value.Value is IEnumerable enumerable)
			{
				IEnumerator enumerator = enumerable.GetEnumerator();
				bool flag = enumerator.MoveNext();
				if (enumerator is IDisposable disposable)
				{
					disposable.Dispose();
				}
				if (!flag)
				{
					return false;
				}
			}
			if ((defaultValuesHandling & DefaultValuesHandling.OmitDefaults) != DefaultValuesHandling.Preserve)
			{
				object objB = key.GetCustomAttribute<DefaultValueAttribute>()?.Value ?? GetDefault(key.Type);
				if (object.Equals(value.Value, objB))
				{
					return false;
				}
			}
			return base.EnterMapping(key, value, context, 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)
		{
			ConcurrentDictionary<Type, MethodInfo[]> concurrentDictionary = stateMethods[attributeType];
			return concurrentDictionary.GetOrAdd(valueType, delegate(Type type)
			{
				MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				return methods.Where((MethodInfo x) => x.GetCustomAttributes(attributeType, 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)
			{
				throw new YamlException(nodeEvent.Start, nodeEvent.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? value2)
			{
				if (array == null)
				{
					throw new InvalidOperationException("Destination array is still null");
				}
				array.SetValue(YamlDotNet.Serialization.Utilities.TypeConverter.ChangeType(value2, 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)
		{
			parser.Consume<SequenceStart>();
			SequenceEnd @event;
			while (!parser.TryConsume<SequenceEnd>(out @event))
			{
				ParsingEvent current = parser.Current;
				object obj = nestedObjectDeserializer(parser, tItem);
				if (obj is IValuePromise valuePromise)
				{
					if (!canUpdate)
					{
						throw new ForwardAnchorNotSupportedException(current?.Start ?? Mark.Empty, current?.End ?? Mark.Empty, "Forward alias references are not allowed because this type does not implement IList<>");
					}
					int index = result.Add(objectFactory.CreatePrimitive(tItem));
					valuePromise.ValueAvailable += delegate(object? v)
					{
						result[index] = v;
					};
				}
				else
				{
					result.Add(obj);
				}
			}
		}
	}
	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)
		{
			parser.Consume<SequenceStart>();
			SequenceEnd @event;
			while (!parser.TryConsume<SequenceEnd>(out @event))
			{
				ParsingEvent current = parser.Current;
				object obj = nestedObjectDeserializer(parser, tItem);
				if (obj is IValuePromise valuePromise)
				{
					if (!canUpdate)
					{
						throw new ForwardAnchorNotSupportedException(current?.Start ?? Mark.Empty, current?.End ?? Mark.Empty, "Forward alias references are not allowed because this type does not implement IList<>");
					}
					int index = result.Add(tItem.IsValueType() ? Activator.CreateInstance(tItem) : null);
					if (promiseResolvedHandler != null)
					{
						valuePromise.ValueAvailable += delegate(object? v)
						{
							promiseResolvedHandler(index, v);
						};
					}
					else
					{
						valuePromise.ValueAvailable += delegate(object? v)
						{
							result[index] = YamlDotNet.Serialization.Utilities.TypeConverter.ChangeType(v, tItem, enumNamingConvention, typeInspector);
						};
					}
				}
				else
				{
					result.Add(YamlDotNet.Serialization.Utilities.TypeConverter.ChangeType(obj, tItem, enumNamingConvention, typeInspector));
				}
			}
		}
	}
	internal abstract class DictionaryDeserializer
	{
		private readonly bool duplicateKeyChecking;

		public DictionaryDeserializer(bool duplicateKeyChecking)
		{
			this.duplicateKeyChecking = duplicateKeyChecking;
		}

		private void TryAssign(IDictionary result, object key, object value, MappingStart propertyName)
		{
			if (duplicateKeyChecking && result.Contains(key))
			{
				throw new YamlException(propertyName.Start, propertyName.End, $"Encountered duplicate key {key}");
			}
			result[key] = value;
		}

		protected virtual void Deserialize(Type tKey, Type tValue, IParser parser, Func<IParser, Type, object?> nestedObjectDeserializer, IDictionary result, ObjectDeserializer rootDeserializer)
		{
			MappingStart property = parser.Consume<MappingStart>();
			MappingEnd @event;
			while (!parser.TryConsume<MappingEnd>(out @event))
			{
				object key = nestedObjectDeserializer(parser, tKey);
				object value = nestedObjectDeserializer(parser, tValue);
				IValuePromise valuePromise = value as IValuePromise;
				if (key is IValuePromise valuePromise2)
				{
					if (valuePromise == null)
					{
						valuePromise2.ValueAvailable += delegate(object? v)
						{
							result[v] = value;
						};
						continue;
					}
					bool hasFirstPart = false;
					valuePromise2.ValueAvailable += delegate(object? v)
					{
						if (hasFirstPart)
						{
							TryAssign(result, v, value, property);
						}
						else
						{
							key = v;
							hasFirstPart = true;
						}
					};
					valuePromise.ValueAvailable += delegate(object? v)
					{
						if (hasFirstPart)
						{
							TryAssign(result, key, v, property);
						}
						else
						{
							value = v;
							hasFirstPart = true;
						}
					};
					continue;
				}
				if (key == null)
				{
					throw new ArgumentException("Empty key names are not supported yet.", "tKey");
				}
				if (valuePromise == null)
				{
					TryAssign(result, key, value, property);
					continue;
				}
				valuePromise.ValueAvailable += delegate(object? v)
				{
					result[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 { Style: ScalarStyle.Plain, IsKey: false } scalar)
			{
				string value = scalar.Value;
				switch (value)
				{
				default:
					return value == "NULL";
				case "":
				case "~":
				case "null":
				case "Null":
					return true;
				}
			}
			return false;
		}
	}
	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))
				{
					throw new YamlException(propertyName.Start, propertyName.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);
					}
				}
				catch (SerializationException ex)
				{
					throw new YamlException(propertyName.Start, propertyName.End, ex.Message);
				}
				catch (YamlException)
				{
					throw;
				}
				catch (Exception innerException)
				{
					throw new YamlException(propertyName.Start, propertyName.End, "Exception during deserialization", innerException);
				}
				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)
			{
				throw new YamlException(propertyName.Start, propertyName.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/*cast due to .constrained prefix*/).Dispose();
			}
		}

		private static object CastInteger(long number, TypeCode typeCode)
		{
			return checked(typeCode switch
			{
				TypeCode.Byte => (byte)number, 
				TypeCode.Int16 => (short)number, 
				TypeCode.Int32 => (int)number, 
				TypeCode.Int64 => number, 
				TypeCode.SByte => (sbyte)number, 
				TypeCode.UInt16 => (ushort)number, 
				TypeCode.UInt32 => (uint)number, 
				TypeCode.UInt64 => (ulong)number, 
				_ => number, 
			});
		}

		private static object CastInteger(ulong number, TypeCode typeCode)
		{
			return checked(typeCode switch
			{
				TypeCode.Byte => (byte)number, 
				TypeCode.Int16 => (short)number, 
				TypeCode.Int32 => (int)number, 
				TypeCode.Int64 => (long)number, 
				TypeCode.SByte => (sbyte)number, 
				TypeCode.UInt16 => (ushort)number, 
				TypeCode.UInt32 => (uint)number, 
				TypeCode.UInt64 => number, 
				_ => number, 
			});
		}

		private 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)
		{
			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 = result.Add(factory.CreatePrimitive(tItem));
					valuePromise.ValueAvailable += delegate(object? v)
					{
						result[index] = v;
					};
				}
				else
				{
					result.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)
		{
			if (typeof(IYamlConvertible).IsAssignableFrom(expectedType))
			{
				IYamlConvertible yamlConvertible = (IYamlConvertible)objectFactory.Create(expectedType);
				yamlConvertible.Read(parser, expectedType, (Type type) => nestedObjectDeserializer(parser, type));
				value = yamlConvertible;
				return true;
			}
			value = null;
			return false;
		}
	}
	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)
		{
			if (!reader.Accept<MappingStart>(out var _))
			{
				value = null;
				return false;
			}
			IEnumerable<ITypeDiscriminator> enumerable = typeDiscriminators.Where((ITypeDiscriminator t) => t.BaseType.IsAssignableFrom(expectedType));
			if (!enumerable.Any())
			{
				value = null;
				return false;
			}
			Mark start = reader.Current.Start;
			Type expectedType2 = expectedType;
			ParserBuffer parserBuffer;
			try
			{
				parserBuffer = new ParserBuffer(reader, maxDepthToBuffer, maxLengthToBuffer);
			}
			catch (Exception innerException)
			{
				throw new YamlException(in start, reader.Current.End, "Failed to buffer yaml node", innerException);
			}
			try
			{
				foreach (ITypeDiscriminator item in enumerable)
				{
					parserBuffer.Reset();
					if (item.TryDiscriminate(parserBuffer, out Type suggestedType))
					{
						expectedType2 = suggestedType;
						break;
					}
				}
			}
			catch (Exception innerException2)
			{
				throw new YamlException(in start, reader.Current.End, "Failed to discriminate type", innerException2);
			}
			parserBuffer.Reset();
			foreach (INodeDeserializer innerDeserializer in innerDeserializers)
			{
				if (innerDeserializer.Deserialize(parserBuffer, expectedType2, nestedObjectDeserializer, out value, 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 scalar2) => targetKey == scalar2.Value, out YamlDotNet.Core.Events.Scalar _, out ParsingEvent value) && value is YamlDotNet.Core.Events.Scalar scalar && typeMapping.TryGetValue(scalar.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))
				{
					throw new YamlException(yamlNode.Start, yamlNode.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/*cast due to .constrained prefix*/).Dispose();
			}
		}

		public IEnumerator<KeyValuePair<YamlNode, YamlNode>> GetEnumerator()
		{
			return children.GetEnumerator();
		}

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

		void IYamlConvertible.Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer)
		{
			Load(parser, new DocumentLoadingState());
		}

		void IYamlConvertible.Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer)
		{
			Emit(emitter, new EmitterState());
		}

		public static YamlMappingNode FromObject(object mapping)
		{
			if (mapping == null)
			{
				throw new ArgumentNullException("mapping");
			}
			YamlMappingNode yamlMappingNode = new YamlMappingNode();
			foreach (PropertyInfo publicProperty in mapping.GetType().GetPublicProperties())
			{
				if (publicProperty.CanRead && publicProperty.GetGetMethod(nonPublic: false).GetParameters().Length == 0)
				{
					object value = publicProperty.GetValue(mapping, null);
					YamlNode yamlNode = value as YamlNode;
					if (yamlNode == null)
					{
						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/*cast due to .constrained prefix*/).Dispose();
			}
		}

		public IEnumerator<YamlNode> GetEnumerator()
		{
			return Children.GetEnumerator();
		}

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

		void IYamlConvertible.Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer)
		{
			Load(parser, new DocumentLoadingState());
		}

		void IYamlConvertible.Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer)
		{
			Emit(emitter, new EmitterState());
		}
	}
	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
			{
				if (dictionary.ContainsKey(key))
				{
					int index = list.FindIndex((KeyValuePair<TKey, TValue> kvp) => comparer.Equals(kvp.Key, key));
					dictionary[key] = value;
					list[index] = new KeyValuePair<TKey, TValue>(key, value);
				}
				else
				{
					Add(key, value);
				}
			}
		}

		public ICollection<TKey> Keys => new KeyCollection(this);

		public ICollection<TValue> Values => new ValueCollection(this);

		public int Count => dictionary.Count;

		public bool IsReadOnly => false;

		public KeyValuePair<TKey, TValue> this[int index]
		{
			get
			{
				return list[index];
			}
			set
			{
				list[index] = value;
			}
		}

		public OrderedDictionary()
			: this((IEqualityComparer<TKey>)EqualityComparer<TKey>.Default)
		{
		}

		public OrderedDictionary(IEqualityComparer<TKey> comparer)
		{
			list = new List<KeyValuePair<TKey, TValue>>();
			dictionary = new Dictionary<TKey, TValue>(comparer);
			this.comparer = comparer;
		}

		public void Add(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)
		{
			if (dictionary.ContainsKey(key))
			{
				int index = list.FindIndex((KeyValuePair<TKey, TValue> kvp) => comparer.Equals(kvp.Key, key));
				list.RemoveAt(index);
				if (!dictionary.Remove(key))
				{
					throw new InvalidOperationException();
				}
				return true;
			}
			return false;
		}

		public bool Remove(KeyValuePair<TKey, TValue> item)
		{
			return Remove(item.Key);
		}

		public void RemoveAt(int index)
		{
			TKey key = list[index].Key;
			dictionary.Remove(key);
			list.RemoveAt(index);
		}

		public bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value)
		{
			return dictionary.TryGetValue(key, out value);
		}

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

		[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/*cast due to .constrained prefix*/).Dispose();
			}
		}

		private bool ValueIsRepresentableInOutputEncoding(string value)
		{
			if (outputUsesUnicodeEncoding)
			{
				return true;
			}
			try
			{
				byte[] bytes = output.Encoding.GetBytes(value);
				string text = output.Encoding.GetString(bytes, 0, bytes.Length);
				return text.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/*cast due to .constrained prefix*/).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/*cast due to .constrained prefix*/).Dispose();
				}
			});
		}

		private void Write(char value)
		{
			output.Write(value);
			column++;
		}

		private void Write(string value)
		{
			output.Write(value);
			column += value.Length;
		}

		private void WriteBreak(char breakCharacter = '\n')
		{
			if (breakCharacter == '\n')
			{
				output.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 { Anchor: { IsEmpty: false } anchor })
				{
					references[anchor] = node;
				}
			}
		}

		private sealed class ParsingEventCloner : IParsingEventVisitor
		{
			private ParsingEvent? clonedEvent;

			public ParsingEvent Clone(ParsingEvent e)
			{
				e.Accept(this);
				if (clonedEvent == null)
				{
					throw new InvalidOperationException($"Could not clone event of type '{e.Type}'");
				}
				return clonedEvent;
			}

			void IParsingEventVisitor.Visit(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)
			{
				clonedEvent = new SequenceEnd(e.Start, e.End);
			}

			void IParsingEventVisitor.Visit(MappingStart e)
			{
				clonedEvent = new MappingStart(AnchorName.Empty, e.Tag, e.IsImplicit, e.Style, e.Start, e.End);
			}

			void IParsingEventVisitor.Visit(MappingEnd e)
			{
				clonedEvent = new MappingEnd(e.Start, e.End);
			}

			void IParsingEventVisitor.Visit(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))
					{
						throw new SemanticErrorException(@event.Value.Start, @event.Value.End, "Unrecognized merge key pattern");
					}
				}
			}
		}

		private bool HandleMerge(LinkedListNode<ParsingEvent>? node)
		{
			if (node == null)
			{
				return false;
			}
			if (node.Value is 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 parsingEventCloner = 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(parsingEventCloner.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();
			if (!(token is YamlDotNet.Core.Tokens.StreamStart streamStart))
			{
				throw new SemanticErrorException(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty, "Did not find expected <stream-start>.");
			}
			Skip();
			state = ParserState.ImplicitDocumentStart;
			return new YamlDotNet.Core.Events.StreamStart(streamStart.Start, streamStart.End);
		}

		private ParsingEvent ParseDocumentStart(bool isImplicit)
		{
			if (currentToken is VersionDirective)
			{
				throw new SyntaxErrorException("While parsing a document start node, could not find document end marker before version directive.");
			}
			Token token = GetCurrentToken();
			if (!isImplicit)
			{
				while (token is YamlDotNet.Core.Tokens.DocumentEnd)
				{
					Skip();
					token = GetCurrentToken();
				}
			}
			if (token == null)
			{
				throw new SyntaxErrorException("Reached the end of the stream while parsing a document start.");
			}
			if (token is YamlDotNet.Core.Tokens.Scalar && (state == ParserState.ImplicitDocumentStart || state == ParserState.DocumentStart))
			{
				isImplicit = true;
			}
			if ((isImplicit && !(token is VersionDirective) && !(token is TagDirective) && !(token is YamlDotNet.Core.Tokens.DocumentStart) && !(token is YamlDotNet.Core.Tokens.StreamEnd) && !(token is YamlDotNet.Core.Tokens.DocumentEnd)) || token is BlockMappingStart)
			{
				TagDirectiveCollection tags = new TagDirectiveCollection();
				ProcessDirectives(tags);
				states.Push(ParserState.DocumentEnd);
				state = ParserState.BlockNode;
				return new YamlDotNet.Core.Events.DocumentStart(null, tags, isImplicit: true, token.Start, token.End);
			}
			if (!(token is YamlDotNet.Core.Tokens.StreamEnd) && !(token is YamlDotNet.Core.Tokens.DocumentEnd))
			{
				Mark start = token.Start;
				TagDirectiveCollection tags2 = new TagDirectiveCollection();
				VersionDirective versionDirective = ProcessDirectives(tags2);
				token = GetCurrentToken() ?? throw new SemanticErrorException("Reached the end of the stream while parsing a document start");
				if (!(token is YamlDotNet.Core.Tokens.DocumentStart))
				{
					throw new SemanticErrorException(token.Start, token.End, "Did not find expected <document start>.");
				}
				states.Push(ParserState.DocumentEnd);
				state = ParserState.DocumentContent;
				Mark end = token.End;
				Skip();
				return new YamlDotNet.Core.Events.DocumentStart(versionDirective, tags2, isImplicit: false, start, end);
			}
			if (token is YamlDotNet.Core.Tokens.DocumentEnd)
			{
				Skip();
			}
			state = ParserState.StreamEnd;
			token = GetCurrentToken() ?? throw new SemanticErrorException("Reached the end of the stream while parsing a document start");
			YamlDotNet.Core.Events.StreamEnd result = new YamlDotNet.Core.Events.StreamEnd(token.Start, token.End);
			if (scanner.MoveNextWithoutConsuming())
			{
				throw new InvalidOperationException("The scanner should contain no more tokens.");
			}
			return result;
		}

		private VersionDirective? ProcessDirectives(TagDirectiveCollection tags)
		{
			bool flag = false;
			VersionDirective result = null;
			while (true)
			{
				if (GetCurrentToken() is VersionDirective versionDirective)
				{
					if (version != null)
					{
						throw new SemanticErrorException(versionDirective.Start, versionDirective.End, "Found duplicate %YAML directive.");
					}
					if (versionDirective.Version.Major != 1 || versionDirective.Version.Minor > 3)
					{
						throw new SemanticErrorException(versionDirective.Start, versionDirective.End, "Found incompatible YAML document.");
					}
					result = (version = versionDirective);
					flag = true;
				}
				else
				{
					if (!(GetCurrentToken() is TagDirective tagDirective))
					{
						break;
					}
					if (tags.Contains(tagDirective.Handle))
					{
						throw new SemanticErrorException(tagDirective.Start, tagDirective.End, "Found duplicate %TAG directive.");
					}
					tags.Add(tagDirective);
					flag = true;
				}
				Skip();
			}
			if (GetCurrentToken() is YamlDotNet.Core.Tokens.DocumentStart && (version == null || (version.Version.Major == 1 && version.Version.Minor > 1)))
			{
				if (GetCurrentToken() is YamlDotNet.Core.Tokens.DocumentStart && version == null)
				{
					version = new VersionDirective(new Version(1, 2));
				}
				flag = true;
			}
			AddTagDirectives(tags, Constants.DefaultTagDirectives);
			if (flag)
			{
				tagDirectives.Clear();
			}
			AddTagDirectives(tagDirectives, tags);
			return result;
		}

		private static void AddTagDirectives(TagDirectiveCollection directives, IEnumerable<TagDirective> source)
		{
			foreach (TagDirective item in source)
			{
				if (!directives.Contains(item))
				{
					directives.Add(item);
				}
			}
		}

		private ParsingEvent ParseDocumentContent()
		{
			if (GetCurrentToken() is VersionDirective || GetCurrentToken() is TagDirective || GetCurrentToken() is YamlDotNet.Core.Tokens.DocumentStart || GetCurrentToken() is YamlDotNet.Core.Tokens.DocumentEnd || GetCurrentToken() is YamlDotNet.Core.Tokens.StreamEnd)
			{
				state = states.Pop();
				return ProcessEmptyScalar(scanner.CurrentPosition);
			}
			return ParseNode(isBlock: true, isIndentlessSequence: false);
		}

		private static 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)
		{
			if (GetCurrentToken() is Error { Start: var start } error)
			{
				throw new SemanticErrorException(in start, error.End, error.Value);
			}
			Token token = GetCurrentToken() ?? throw new SemanticErrorException("Reached the end of the stream while parsing a node");
			if (token is YamlDotNet.Core.Tokens.AnchorAlias anchorAlias)
			{
				state = states.Pop();
				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 { Start: var start3 } anchor4)
						{
							throw new SemanticErrorException(in start3, anchor4.End, "While parsing a node, found more than one anchor.");
						}
						if (token is YamlDotNet.Core.Tokens.AnchorAlias { Start: var start4 } anchorAlias2)
						{
							throw new SemanticErrorException(in start4, anchorAlias2.End, "While parsing a node, did not find expected token.");
						}
						if (!(token is Error error2))
						{
							break;
						}
						if (tag2 != null && anchor2 != null && !anchor.IsEmpty)
						{
							return new YamlDotNet.Core.Events.Scalar(anchor, default(TagName), string.Empty, ScalarStyle.Any, isPlainImplicit: false, isQuotedImplicit: false, anchor2.Start, anchor2.End);
						}
						throw new SemanticErrorException(error2.Start, error2.End, error2.Value);
					}
					tag2 = tag3;
					if (string.IsNullOrEmpty(tag3.Handle))
					{
						tag = new TagName(tag3.Suffix);
					}
					else
					{
						if (!tagDirectives.Contains(tag3.Handle))
						{
							throw new SemanticErrorException(tag3.Start, tag3.End, "While parsing a node, found undefined tag handle.");
						}
						tag = new TagName(tagDirectives[tag3.Handle].Prefix + tag3.Suffix);
					}
					Skip();
				}
				token = GetCurrentToken() ?? throw new SemanticErrorException("Reached the end of the stream while parsing a node");
			}
			bool isEmpty = tag.IsEmpty;
			if (isIndentlessSequence && GetCurrentToken() is BlockEntry)
			{
				state = ParserState.IndentlessSequenceEntry;
				return new SequenceStart(anchor, tag, isEmpty, SequenceStyle.Block, start2, token.End);
			}
			if (token is YamlDotNet.Core.Tokens.Scalar scalar)
			{
				bool isPlainImplicit = false;
				bool isQuotedImplicit = false;
				if ((scalar.Style == ScalarStyle.Plain && tag.IsEmpty) || tag.IsNonSpecific)
				{
					isPlainImplicit = true;
				}
				else if (tag.IsEmpty)
				{
					isQuotedImplicit = true;
				}
				state = states.Pop();
				Skip();
				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;
						throw new SemanticErrorException(error3.Start, error3.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))
					{
						throw new SemanticErrorException(currentToken.Start, currentToken.End, "While parsing a flow mapping, did not find expected ',' or '}'.");
					}
				}
				return result2;
			}
			if (token is FlowSequenceStart flowSequenceStart)
			{
				state = ParserState.FlowSequenceFirstEntry;
				return new SequenceStart(anchor, tag, isEmpty, SequenceStyle.Flow, start2, flowSequenceStart.End);
			}
			if (token is FlowMappingStart flowMappingStart)
			{
				state = ParserState.FlowMappingFirstKey;
				return new MappingStart(anchor, tag, isEmpty, MappingStyle.Flow, start2, flowMappingStart.End);
			}
			if (isBlock)
			{
				if (token is BlockSequenceStart blockSequenceStart)
				{
					state = ParserState.BlockSequenceFirstEntry;
					return new SequenceStart(anchor, tag, isEmpty, SequenceStyle.Block, start2, blockSequenceStart.End);
				}
				if (token is BlockMappingStart blockMappingStart)
				{
					state = ParserState.BlockMappingFirstKey;
					return new MappingStart(anchor, tag, isEmpty, MappingStyle.Block, start2, blockMappingStart.End);
				}
			}
			if (!anchor.IsEmpty || !tag.IsEmpty)
			{
				state = states.Pop();
				return new YamlDotNet.Core.Events.Scalar(anchor, tag, string.Empty, ScalarStyle.Plain, isEmpty, isQuotedImplicit: false, start2, token.End);
			}
			throw new SemanticErrorException(token.Start, token.End, "While parsing a node, did not find expected node content.");
		}

		private 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 { End: var position })
			{
				Skip();
				token = GetCurrentToken();
				if (!(token is BlockEntry) && !(token is BlockEnd))
				{
					states.Push(ParserState.BlockSequenceEntry);
					return ParseNode(isBlock: true, isIndentlessSequence: false);
				}
				state = ParserState.BlockSequenceEntry;
				return ProcessEmptyScalar(in position);
			}
			if (token is BlockEnd blockEnd)
			{
				state = states.Pop();
				ParsingEvent result = new SequenceEnd(blockEnd.Start, blockEnd.End);
				Skip();
				return result;
			}
			throw new SemanticErrorException(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty, "While parsing a block collection, did not find expected '-' indicator.");
		}

		private ParsingEvent ParseIndentlessSequenceEntry()
		{
			Token token = GetCurrentToken();
			if (token is BlockEntry { End: var position })
			{
				Skip();
				token = GetCurrentToken();
				if (!(token is BlockEntry) && !(token is Key) && !(token is Value) && !(token is BlockEnd))
				{
					states.Push(ParserState.IndentlessSequenceEntry);
					return ParseNode(isBlock: true, isIndentlessSequence: false);
				}
				state = ParserState.IndentlessSequenceEntry;
				return ProcessEmptyScalar(in position);
			}
			state = states.Pop();
			return new SequenceEnd(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty);
		}

		private ParsingEvent ParseBlockMappingKey(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			Token token = GetCurrentToken();
			if (token is Key { End: var position })
			{
				Skip();
				token = GetCurrentToken();
				if (!(token is Key) && !(token is Value) && !(token is BlockEnd))
				{
					states.Push(ParserState.BlockMappingValue);
					return ParseNode(isBlock: true, isIndentlessSequence: true);
				}
				state = ParserState.BlockMappingValue;
				return ProcessEmptyScalar(in position);
			}
			if (token is Value value)
			{
				Skip();
				return ProcessEmptyScalar(value.End);
			}
			if (token is YamlDotNet.Core.Tokens.AnchorAlias anchorAlias)
			{
				Skip();
				return new YamlDotNet.Core.Events.AnchorAlias(anchorAlias.Value, anchorAlias.Start, anchorAlias.End);
			}
			if (token is BlockEnd blockEnd)
			{
				state = states.Pop();
				ParsingEvent result = new MappingEnd(blockEnd.Start, blockEnd.End);
				Skip();
				return result;
			}
			if (GetCurrentToken() is Error { Start: var start } error)
			{
				throw new SyntaxErrorException(in start, error.End, error.Value);
			}
			throw new SemanticErrorException(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty, "While parsing a block mapping, did not find expected key.");
		}

		private ParsingEvent ParseBlockMappingValue()
		{
			Token token = GetCurrentToken();
			if (token is Value { End: var position })
			{
				Skip();
				token = GetCurrentToken();
				if (!(token is Key) && !(token is Value) && !(token is BlockEnd))
				{
					states.Push(ParserState.BlockMappingKey);
					return ParseNode(isBlock: true, isIndentlessSequence: true);
				}
				state = ParserState.BlockMappingKey;
				return ProcessEmptyScalar(in position);
			}
			if (token is Error { Start: var start } error)
			{
				throw new SemanticErrorException(in start, error.End, error.Value);
			}
			state = ParserState.BlockMappingKey;
			return ProcessEmptyScalar(token?.Start ?? Mark.Empty);
		}

		private ParsingEvent ParseFlowSequenceEntry(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			Token token = GetCurrentToken();
			ParsingEvent result;
			if (!(token is FlowSequenceEnd))
			{
				if (!isFirst)
				{
					if (!(token is FlowEntry))
					{
						throw new SemanticErrorException(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty, "While parsing a flow sequence, did not find expected ',' or ']'.");
					}
					Skip();
					token = GetCurrentToken();
				}
				if (token is Key)
				{
					state = ParserState.FlowSequenceEntryMappingKey;
					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();
			result = new SequenceEnd(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty);
			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;
			return ProcessEmptyScalar(token?.Start ?? Mark.Empty);
		}

		private MappingEnd ParseFlowSequenceEntryMappingEnd()
		{
			state = ParserState.FlowSequenceEntry;
			Token token = GetCurrentToken();
			return new MappingEnd(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty);
		}

		private ParsingEvent ParseFlowMappingKey(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			Token token = GetCurrentToken();
			if (!(token is FlowMappingEnd))
			{
				if (!isFirst)
				{
					if (token is FlowEntry)
					{
						Skip();
						token = GetCurrentToken();
					}
					else if (!(token is YamlDotNet.Core.Tokens.Scalar))
					{
						throw new SemanticErrorException(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty, "While parsing a flow mapping,  did not find expected ',' or '}'.");
					}
				}
				if (token is Key)
				{
					Skip();
					token = GetCurrentToken();
					if (!(token is Value) && !(token is FlowEntry) && !(token is FlowMappingEnd))
					{
						states.Push(ParserState.FlowMappingValue);
						return ParseNode(isBlock: false, isIndentlessSequence: false);
					}
					state = ParserState.FlowMappingValue;
					return ProcessEmptyScalar(token?.Start ?? Mark.Empty);
				}
				if (token is YamlDotNet.Core.Tokens.Scalar)
				{
					states.Push(ParserState.FlowMappingValue);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
				if (!(token is FlowMappingEnd))
				{
					states.Push(ParserState.FlowMappingEmptyValue);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
			}
			state = states.Pop();
			Skip();
			return new MappingEnd(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty);
		}

		private ParsingEvent ParseFlowMappingValue(bool isEmpty)
		{
			Token token = GetCurrentToken();
			if (!isEmpty && token is Value)
			{
				Skip();
				token = GetCurrentToken();
				if (!(token is FlowEntry) && !(token is FlowMappingEnd))
				{
					states.Push(ParserState.FlowMappingKey);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
			}
			state = ParserState.FlowMappingKey;
			if (!isEmpty && token is YamlDotNet.Core.Tokens.Scalar scalar)
			{
				Skip();
				return new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, scalar.Value, scalar.Style, isPlainImplicit: false, isQuotedImplicit: false, token.Start, scalar.End);
			}
			return ProcessEmptyScalar(token?.Start ?? Mark.Empty);
		}
	}
	internal static class ParserExtensions
	{
		public static T Consume<T>(this IParser parser) where T : ParsingEvent
		{
			T result = parser.Require<T>();
			parser.MoveNext();
			return result;
		}

		public static bool TryConsume<T>(this IParser parser, [MaybeNullWhen(false)] out T @event) where T : ParsingEvent
		{
			if (parser.Accept<T>(out @event))
			{
				parser.MoveNext();
				return true;
			}
			return false;
		}

		public static T Require<T>(this IParser parser) where T : ParsingEvent
		{
			if (!parser.Accept<T>(out var @event))
			{
				ParsingEvent current = parser.Current;
				if (current == null)
				{
					throw new YamlException("Expected '" + typeof(T).Name + "', got nothing.");
				}
				throw new YamlException(current.Start, current.End, $"Expected '{typeof(T).Name}', got '{current.GetType().Name}' (at {current.Start}).");
			}
			return @event;
		}

		public static bool Accept<T>(this IParser parser, [MaybeNullWhen(false)] out T @event) where T : ParsingEvent
		{
			if (parser.Current == null && !parser.MoveNext())
			{
				throw new EndOfStreamException();
			}
			if (parser.Current is T val)
			{
				@event = val;
				return true;
			}
			@event = null;
			return false;
		}

		public static void SkipThisAndNestedEvents(this IParser parser)
		{
			int num = 0;
			do
			{
				ParsingEvent parsingEvent = parser.Consume<ParsingEvent>();
				num += parsingEvent.NestingIncrease;
			}
			while (num > 0);
		}

		[Obsolete("Please use Consume<T>() instead")]
		public static T Expect<T>(this IParser parser) where T : ParsingEvent
		{
			return parser.Consume<T>();
		}

		[Obsolete("Please use TryConsume<T>(out var evt) instead")]
		[return: MaybeNull]
		public static T? Allow<T>(this IParser parser) where T : ParsingEvent
		{
			if (!parser.TryConsume<T>(out var @event))
			{
				return null;
			}
			return @event;
		}

		[Obsolete("Please use Accept<T>(out var evt) instead")]
		[return: MaybeNull]
		public static T? Peek<T>(this IParser parser) where T : ParsingEvent
		{
			if (!parser.Accept<T>(out var @event))
			{
				return null;
			}
			return @event;
		}

		[Obsolete("Please use TryConsume<T>(out var evt) or Accept<T>(out var evt) instead")]
		public static bool Accept<T>(this IParser parser) where T : ParsingEvent
		{
			T @event;
			return parser.Accept<T>(out @event);
		}

		public static bool TryFindMappingEntry(this IParser parser, Func<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();
					throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning for the next token, found character that cannot start any token.");
				}
				Skip();
			}
		}

		private bool CheckWhiteSpace()
		{
			if (!analyzer.Check(' '))
			{
				if (flowLevel > 0 || !simpleKeyAllowed)
				{
					return analyzer.Check('\t');
				}
				return false;
			}
			return true;
		}

		private void Skip()
		{
			cursor.Skip();
			analyzer.Buffer.Skip(1);
		}

		private void SkipLine()
		{
			if (analyzer.IsCrLf())
			{
				cursor.SkipLineByOffset(2);
				analyzer.Buffer.Skip(2);
			}
			else if (analyzer.IsBreak())
			{
				cursor.SkipLineByOffset(1);
				analyzer.Buffer.Skip(1);
			}
			else if (!analyzer.IsZero())
			{
				throw new InvalidOperationException("Not at a break.");
			}
		}

		private void ScanToNextToken()
		{
			while (true)
			{
				if (CheckWhiteSpace())
				{
					Skip();
					continue;
				}
				ProcessComment();
				if (analyzer.IsBreak())
				{
					SkipLine();
					if (flowLevel == 0)
					{
						simpleKeyAllowed = true;
					}
					continue;
				}
				break;
			}
		}

		private void ProcessComment()
		{
			if (!analyzer.Check('#'))
			{
				return;
			}
			Mark start = cursor.Mark();
			Skip();
			while (analyzer.IsSpace())
			{
				Skip();
			}
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				while (!analyzer.IsBreakOrZero())
				{
					builder.Append(ReadCurrentCharacter());
				}
				if (!SkipComments)
				{
					bool isInline = previous != null && previous.End.Line == start.Line && previous.End.Column != 1 && !(previous is YamlDotNet.Core.Tokens.StreamStart);
					tokens.Enqueue(new YamlDotNet.Core.Tokens.Comment(builder.ToString(), isInline, start, cursor.Mark()));
				}
			}
			finally
			{
				((IDisposable)builderWrapper/*cast due to .constrained prefix*/).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))
				{
					throw new SemanticErrorException(in start, cursor.Mark(), "While scanning a version directive, did not find preceding <document end>.");
				}
				result = ScanVersionDirectiveValue(in start);
			}
			while (analyzer.IsWhite())
			{
				Skip();
			}
			ProcessComment();
			if (!analyzer.IsBreakOrZero())
			{
				throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a directive, did not find expected comment or line break.");
			}
			if (analyzer.IsBreak())
			{
				SkipLine();
			}
			return result;
		}

		private void FetchDocumentIndicator(bool isStartToken)
		{
			UnrollIndent(-1L);
			RemoveSimpleKey();
			simpleKeyAllowed = false;
			Mark start = cursor.Mark();
			Skip();
			Skip();
			Skip();
			if (isStartToken)
			{
				tokens.Enqueue(new YamlDotNet.Core.Tokens.DocumentStart(in start, cursor.Mark()));
				return;
			}
			Token token = null;
			while (!analyzer.EndOfInput && !analyzer.IsBreak() && !analyzer.Check('#'))
			{
				if (!analyzer.IsWhite())
				{
					token = new Error("While scanning a document end, found invalid content after '...' marker.", start, cursor.Mark());
					break;
				}
				Skip();
			}
			tokens.Enqueue(new YamlDotNet.Core.Tokens.DocumentEnd(in start, in start));
			if (token != null)
			{
				tokens.Enqueue(token);
			}
		}

		private void FetchFlowCollectionStart(bool isSequenceToken)
		{
			SaveSimpleKey();
			IncreaseFlowLevel();
			simpleKeyAllowed = true;
			Mark start = cursor.Mark();
			Skip();
			Token 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()
		{
			if (flowLevel == 0)
			{
				if (!simpleKeyAllowed)
				{
					if (previousAnchor != null && previousAnchor.End.Line == cursor.Line)
					{
						throw new SemanticErrorException(previousAnchor.Start, previousAnchor.End, "Anchor before sequence entry on same line is not allowed.");
					}
					Mark mark = cursor.Mark();
					tokens.Enqueue(new Error("Block sequence entries are not allowed in this context.", mark, mark));
				}
				RollIndent(cursor.LineOffset, -1, isSequence: true, cursor.Mark());
			}
			RemoveSimpleKey();
			simpleKeyAllowed = true;
			Mark start = cursor.Mark();
			Skip();
			tokens.Enqueue(new BlockEntry(in start, cursor.Mark()));
		}

		private void FetchKey()
		{
			if (flowLevel == 0)
			{
				if (!simpleKeyAllowed)
				{
					Mark start = cursor.Mark();
					throw new SyntaxErrorException(in start, in start, "Mapping keys are not allowed in this context.");
				}
				RollIndent(cursor.LineOffset, -1, isSequence: false, cursor.Mark());
			}
			RemoveSimpleKey();
			simpleKeyAllowed = flowLevel == 0;
			Mark start2 = cursor.Mark();
			Skip();
			tokens.Enqueue(new Key(in start2, cursor.Mark()));
		}

		private void FetchValue()
		{
			SimpleKey simpleKey = simpleKeys.Peek();
			if (simpleKey.IsPossible)
			{
				tokens.Insert(simpleKey.TokenNumber - tokensParsed, new Key(simpleKey.Mark, simpleKey.Mark));
				RollIndent(simpleKey.LineOffset, simpleKey.TokenNumber, isSequence: false, simpleKey.Mark);
				simpleKey.MarkAsImpossible();
				simpleKeyAllowed = false;
			}
			else
			{
				bool flag = flowLevel == 0;
				if (flag)
				{
					if (!simpleKeyAllowed)
					{
						Mark mark = cursor.Mark();
						tokens.Enqueue(new Error("Mapping values are not allowed in this context.", mark, mark));
						return;
					}
					RollIndent(cursor.LineOffset, -1, isSequence: false, cursor.Mark());
					if (cursor.LineOffset == 0L && simpleKey.LineOffset == 0L)
					{
						tokens.Insert(tokens.Count, new Key(simpleKey.Mark, simpleKey.Mark));
						flag = false;
					}
				}
				simpleKeyAllowed = flag;
			}
			Mark start = cursor.Mark();
			Skip();
			tokens.Enqueue(new Value(in start, cursor.Mark()));
		}

		private void RollIndent(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("?:,]}%@`")))
				{
					throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning an anchor or alias, found value containing disallowed: []{},");
				}
				AnchorName value = new AnchorName(builder.ToString());
				if (isAlias)
				{
					return new YamlDotNet.Core.Tokens.AnchorAlias(value, start, cursor.Mark());
				}
				return previousAnchor = new Anchor(value, start, cursor.Mark());
			}
			finally
			{
				((IDisposable)builderWrapper/*cast due to .constrained prefix*/).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('>'))
				{
					throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a tag, did not find the expected '>'.");
				}
				Skip();
			}
			else
			{
				string text3 = ScanTagHandle(isDirective: false, start);
				if (text3.Length > 1 && text3[0] == '!' && text3[text3.Length - 1] == '!')
				{
					text = text3;
					text2 = ScanTagUri(null, start);
				}
				else
				{
					text2 = ScanTagUri(text3, start);
					text = "!";
					if (text2.Length == 0)
					{
						text2 = text;
						text = string.Empty;
					}
				}
			}
			if (!analyzer.IsWhiteBreakOrZero() && !analyzer.Check(','))
			{
				throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a tag, did not find expected whitespace, comma or line break.");
			}
			return new Tag(text, text2, start, cursor.Mark());
		}

		private void FetchBlockScalar(bool isLiteral)
		{
			SaveSimpleKey();
			simpleKeyAllowed = true;
			tokens.Enqueue(ScanBlockScalar(isLiteral));
		}

		private 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'))
								{
									throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a block scalar, found an indentation indicator equal to 0.");
								}
								num2 = analyzer.AsDigit();
								Skip();
							}
						}
						else if (analyzer.IsDigit())
						{
							if (analyzer.Check('0'))
							{
								throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a block scalar, found an indentation indicator equal to 0.");
							}
							num2 = analyzer.AsDigit();
							Skip();
							if (analyzer.Check("+-"))
							{
								num = (analyzer.Check('+') ? 1 : (-1));
								Skip();
							}
						}
						if (analyzer.Check('#'))
						{
							throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a block scalar, found a comment without whtespace after '>' indicator.");
						}
						while (analyzer.IsWhite())
						{
							Skip();
						}
						ProcessComment();
						if (!analyzer.IsBreakOrZero())
						{
							throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a block scalar, did not find expected comment or line break.");
						}
						if (analyzer.IsBreak())
						{
							SkipLine();
							if (!isFirstLine.HasValue)
							{
								isFirstLine = true;
							}
							else if (isFirstLine == true)
							{
								isFirstLine = false;
							}
						}
						Mark end = cursor.Mark();
						if (num2 != 0)
						{
							currentIndent = ((indent >= 0) ? (indent + num2) : num2);
						}
						currentIndent = ScanBlockScalarBreaks(currentIndent, builder3, isLiteral, ref end, ref isFirstLine);
						isFirstLine = false;
						while (cursor.LineOffset == currentIndent && !analyzer.IsZero() && !IsDocumentEnd())
						{
							bool flag2 = analyzer.IsWhite();
							if (!isLiteral && StartsWith(builder2, '\n') && !flag && !flag2)
							{
								if (builder3.Length == 0)
								{
									builder.Append(' ');
								}
								builder2.Length = 0;
							}
							else
							{
								builder.Append((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 end, ref isFirstLine);
						}
						if (num != -1)
						{
							builder.Append((object?)builder2);
						}
						if (num == 1)
						{
							builder.Append((object?)builder3);
						}
						ScalarStyle style = (isLiteral ? ScalarStyle.Literal : ScalarStyle.Folded);
						return new YamlDotNet.Core.Tokens.Scalar(builder.ToString(), style, start, end);
					}
					finally
					{
						((IDisposable)builderWrapper3/*cast due to .constrained prefix*/).Dispose();
					}
				}
				finally
				{
					((IDisposable)builderWrapper2/*cast due to .constrained prefix*/).Dispose();
				}
			}
			finally
			{
				((IDisposable)builderWrapper/*cast due to .constrained prefix*/).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 == true)
				{
					isFirstLine = false;
					num2 = cursor.LineOffset;
				}
				breaks.Append(ReadLine());
				end = cursor.Mark();
			}
			if (isLiteral && isFirstLine == true)
			{
				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)
			{
				throw new SemanticErrorException(in end, cursor.Mark(), "While scanning a literal block scalar, found extra spaces in first line.");
			}
			if (!isLiteral && num > cursor.LineOffset && num2 > -1)
			{
				throw new SemanticErrorException(in end, cursor.Mark(), "While scanning a literal block scalar, found more spaces in lines above first content line.");
			}
			if (currentIndent == 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())
								{
									throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a quoted scalar, found unexpected document indicator.");
								}
								if (analyzer.IsZero())
								{
									throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a quoted scalar, found unexpected end of stream.");
								}
								if (flag && !isSingleQuoted && indent >= cursor.LineOffset)
								{
									throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a multi-line double-quoted scalar, found wrong indentation.");
								}
								flag = false;
								while (!analyzer.IsWhiteBreakOrZero())
								{
									if (isSingleQuoted && analyzer.Check('\'') && analyzer.Check('\'', 1))
									{
										builder.Append('\'');
										Skip();
										Skip();
										continue;
									}
									if (analyzer.Check(isSingleQuoted ? '\'' : '"'))
									{
										break;
									}
									if (!isSingleQuoted && analyzer.Check('\\') && analyzer.IsBreak(1))
									{
										Skip();
										SkipLine();
										flag = true;
										break;
									}
									if (!isSingleQuoted && analyzer.Check('\\'))
									{
										int num = 0;
										char c = analyzer.Peek(1);
										switch (c)
										{
										case 'x':
											num = 2;
											break;
										case 'u':
											num = 4;
											break;
										case 'U':
											num = 8;
											break;
										default:
										{
											if (SimpleEscapeCodes.TryGetValue(c, out var value))
											{
												builder.Append(value);
												break;
											}
											throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a quoted scalar, found unknown escape character.");
										}
										}
										Skip();
										Skip();
										if (num <= 0)
										{
											continue;
										}
										int num2 = 0;
										for (int i = 0; i < num; i++)
										{
											if (!analyzer.IsHex(i))
											{
												throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a quoted scalar, did not find expected hexadecimal number.");
											}
											num2 = (num2 << 4) + analyzer.AsHex(i);
										}
										if (num2 >= 55296 && num2 <= 57343)
										{
											for (int j = 0; j < num; j++)
											{
												Skip();
											}
											if (analyzer.Peek(0) != '\\' || (analyzer.Peek(1) != 'u' && analyzer.Peek(1) != 'U'))
											{
												throw new SyntaxErrorException(in start, cursor.Mark(), "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))
												{
													throw new SyntaxErrorException(in start, cursor.Mark(), "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)
											{
												throw new SyntaxErrorException(in start, cursor.Mark(), "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/*cast due to .constrained prefix*/).Dispose();
						}
					}
					finally
					{
						((IDisposable)builderWrapper3/*cast due to .constrained prefix*/).Dispose();
					}
				}
				finally
				{
					((IDisposable)builderWrapper2/*cast due to .constrained prefix*/).Dispose();
				}
			}
			finally
			{
				((IDisposable)builderWrapper/*cast due to .constrained prefix*/).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())
										{
											throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a plain scalar, found a tab character that violate indentation.");
										}
										if (!flag)
										{
											builder2.Append(ReadCurrentCharacter());
										}
										else
										{
											Skip();
										}
									}
									else
									{
										isMultiline = true;
										if (!flag)
										{
											builder2.Length = 0;
											builder3.Append(ReadLine());
											flag = true;
										}
										else
										{
											builder4.Append(ReadLine());
										}
									}
								}
								if (flowLevel == 0 && cursor.LineOffset < num)
								{
									break;
								}
							}
							if (flag)
							{
								simpleKeyAllowed = true;
							}
							return new YamlDotNet.Core.Tokens.Scalar(builder.ToString(), ScalarStyle.Plain, start, end);
						}
						finally
						{
							((IDisposable)builderWrapper4/*cast due to .constrained prefix*/).Dispose();
						}
					}
					finally
					{
						((IDisposable)builderWrapper3/*cast due to .constrained prefix*/).Dispose();
					}
				}
				finally
				{
					((IDisposable)builderWrapper2/*cast due to .constrained prefix*/).Dispose();
				}
			}
			finally
			{
				((IDisposable)builderWrapper/*cast due to .constrained prefix*/).Dispose();
			}
		}

		private void RemoveSimpleKey()
		{
			SimpleKey simpleKey = simpleKeys.Peek();
			if (simpleKey.IsPossible && simpleKey.IsRequired)
			{
				throw new SyntaxErrorException(simpleKey.Mark, simpleKey.Mark, "While scanning a simple key, could not find expected ':'.");
			}
			simpleKey.MarkAsImpossible();
		}

		private string ScanDirectiveName(in Mark start)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				while (analyzer.IsAlphaNumericDashOrUnderscore())
				{
					builder.Append(ReadCurrentCharacter());
				}
				if (builder.Length == 0)
				{
					throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a directive, could not find expected directive name.");
				}
				if (analyzer.EndOfInput)
				{
					throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a directive, found unexpected end of stream.");
				}
				if (!analyzer.IsWhiteBreakOrZero())
				{
					throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a directive, found unexpected non-alphabetical character.");
				}
				return builder.ToString();
			}
			finally
			{
				((IDisposable)builderWrapper/*cast due to .constrained prefix*/).Dispose();
			}
		}

		private void SkipWhitespaces()
		{
			while (analyzer.IsWhite())
			{
				Skip();
			}
		}

		private VersionDirective ScanVersionDirectiveValue(in Mark start)
		{
			SkipWhitespaces();
			int major = ScanVersionDirectiveNumber(in start);
			if (!analyzer.Check('.'))
			{
				throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a %YAML directive, did not find expected digit or '.' character.");
			}
			Skip();
			int minor = ScanVersionDirectiveNumber(in start);
			return new VersionDirective(new Version(major, minor), start, start);
		}

		private TagDirective ScanTagDirectiveValue(in Mark start)
		{
			SkipWhitespaces();
			string handle = ScanTagHandle(isDirective: true, start);
			if (!analyzer.IsWhite())
			{
				throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a %TAG directive, did not find expected whitespace.");
			}
			SkipWhitespaces();
			string prefix = ScanTagUri(null, start);
			if (!analyzer.IsWhiteBreakOrZero())
			{
				throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a %TAG directive, did not find expected whitespace or line break.");
			}
			return new TagDirective(handle, prefix, start, start);
		}

		private string ScanTagUri(string? head, Mark start)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				if (head != null && head.Length > 1)
				{
					builder.Append(head.Substring(1));
				}
				while (analyzer.IsAlphaNumericDashOrUnderscore() || analyzer.Check(";/?:@&=+$.!~*'()[]%") || (analyzer.Check(',') && !analyzer.IsBreak(1)))
				{
					if (analyzer.Check('%'))
					{
						builder.Append(ScanUriEscapes(in start));
					}
					else if (analyzer.Check('+'))
					{
						builder.Append(' ');
						Skip();
					}
					else
					{
						builder.Append(ReadCurrentCharacter());
					}
				}
				if (builder.Length == 0)
				{
					return string.Empty;
				}
				string text = builder.ToString();
				if (Polyfills.EndsWith(text, ','))
				{
					throw new SyntaxErrorException(cursor.Mark(), cursor.Mark(), "Unexpected comma at end of tag");
				}
				return text;
			}
			finally
			{
				((IDisposable)builderWrapper/*cast due to .constrained prefix*/).Dispose();
			}
		}

		private string ScanUriEscapes(in Mark start)
		{
			byte[] array = EmptyBytes;
			int count = 0;
			int num = 0;
			do
			{
				if (!analyzer.Check('%') || !analyzer.IsHex(1) || !analyzer.IsHex(2))
				{
					throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a tag, did not find URI escaped octet.");
				}
				int num2 = (analyzer.AsHex(1) << 4) + analyzer.AsHex(2);
				if (num == 0)
				{
					num = (((num2 & 0x80) == 0) ? 1 : (((num2 & 0xE0) == 192) ? 2 : (((num2 & 0xF0) == 224) ? 3 : (((num2 & 0xF8) == 240) ? 4 : 0))));
					if (num == 0)
					{
						throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a tag, found an incorrect leading UTF-8 octet.");
					}
					array = new byte[num];
				}
				else if ((num2 & 0xC0) != 128)
				{
					throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a tag, found an incorrect trailing UTF-8 octet.");
				}
				array[count++] = (byte)num2;
				Skip();
				Skip();
				Skip();
			}
			while (--num > 0);
			string text = Encoding.UTF8.GetString(array, 0, count);
			if (text.Length == 0 || text.Length > 2)
			{
				throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a tag, found an incorrect UTF-8 sequence.");
			}
			return text;
		}

		private string ScanTagHandle(bool isDirective, Mark start)
		{
			if (!analyzer.Check('!'))
			{
				throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a tag, did not find expected '!'.");
			}
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				builder.Append(ReadCurrentCharacter());
				while (analyzer.IsAlphaNumericDashOrUnderscore())
				{
					builder.Append(ReadCurrentCharacter());
				}
				if (analyzer.Check('!'))
				{
					builder.Append(ReadCurrentCharacter());
				}
				else if (isDirective && (builder.Length != 1 || builder[0] != '!'))
				{
					throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a tag directive, did not find expected '!'.");
				}
				return builder.ToString();
			}
			finally
			{
				((IDisposable)builderWrapper/*cast due to .constrained prefix*/).Dispose();
			}
		}

		private int ScanVersionDirectiveNumber(in Mark start)
		{
			int num = 0;
			int num2 = 0;
			while (analyzer.IsDigit())
			{
				if (++num2 > 9)
				{
					throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a %YAML directive, found extremely long version number.");
				}
				num = num * 10 + analyzer.AsDigit();
				Skip();
			}
			if (num2 == 0)
			{
				throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a %YAML directive, did not find expected version number.");
			}
			return num;
		}

		private void SaveSimpleKey()
		{
			bool isRequired = flowLevel == 0 && indent == cursor.LineOffset;
			if (simpleKeyAllowed)
			{
				SimpleKey item = new SimpleKey(isRequired, tokensParsed + tokens.Count, cursor);
				RemoveSimpleKey();
				simpleKeys.Pop();
				simpleKeys.Push(item);
			}
		}
	}
	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;
		}
	}
}