using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security.Cryptography;
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.Managers;
using Microsoft.CodeAnalysis;
using ServerSync;
using Splatform;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
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.RepresentationModel;
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("PortalRules")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("sighsorry")]
[assembly: AssemblyProduct("PortalRules")]
[assembly: AssemblyCopyright("Copyright © 2026 sighsorry")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("4358610B-F3F4-4843-B7AF-98B7BC60DCDE")]
[assembly: AssemblyFileVersion("1.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
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;
		}
	}
}
namespace PortalRules
{
	internal static class AdminPortalBiomeDefaults
	{
		private sealed class BiomeDefaultsYaml
		{
			[YamlMember(Alias = "format_version")]
			public int FormatVersion { get; set; }

			[YamlMember(Alias = "biomes")]
			public Dictionary<string, string?>? Biomes { get; set; }
		}

		[HarmonyPatch(typeof(ZoneSystem), "Start")]
		[HarmonyAfter(new string[] { "expand_world_data" })]
		[HarmonyPriority(0)]
		private static class BiomeRegistryReadyPatch
		{
			private static void Postfix()
			{
				if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
				{
					CompleteBiomeRegistryInitialization();
				}
			}
		}

		private const int FormatVersion = 1;

		private const int MaximumBiomeCount = 4096;

		private const int MaximumBiomeNameLength = 128;

		private const int MaximumReloadAttempts = 5;

		private const long MaximumFileBytes = 524288L;

		private const string DirectoryName = "PortalRules";

		private const string FileName = "admin-portal-biome-global-keys.yml";

		private const float RegistryReadyFallbackSeconds = 5f;

		private static readonly KeyValuePair<string, string>[] VanillaTemplate = new KeyValuePair<string, string>[9]
		{
			new KeyValuePair<string, string>("Meadows", ""),
			new KeyValuePair<string, string>("BlackForest", "defeated_eikthyr"),
			new KeyValuePair<string, string>("Swamp", "defeated_gdking"),
			new KeyValuePair<string, string>("Ocean", "defeated_bonemass"),
			new KeyValuePair<string, string>("Mountain", "defeated_bonemass"),
			new KeyValuePair<string, string>("Plains", "defeated_dragon"),
			new KeyValuePair<string, string>("Mistlands", "defeated_goblinking"),
			new KeyValuePair<string, string>("AshLands", "defeated_queen"),
			new KeyValuePair<string, string>("DeepNorth", "defeated_fader")
		};

		private static readonly HashSet<string> AmbiguousPlainYamlScalars = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "null", "true", "false", "y", "n", "yes", "no", "on", "off" };

		private static readonly TimeSpan ReloadDebounce = TimeSpan.FromMilliseconds(500.0);

		private static readonly TimeSpan ReloadRetryDelay = TimeSpan.FromSeconds(1.0);

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

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

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

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

		private static FileSystemWatcher? _watcher;

		private static string _configurationDirectory = "";

		private static string _filePath = "";

		private static bool _active;

		private static bool _hasValidSnapshot;

		private static bool _templatePending;

		private static bool _biomeRegistryReady;

		private static bool _registryFallbackLogged;

		private static float _registryFallbackNotBefore;

		private static DateTime _templateRetryNotBeforeUtc;

		private static DateTime _nextPollUtc;

		private static int _reloadRequested;

		private static int _reloadAttempts;

		private static int _watcherRestartRequested;

		private static long _reloadNotBeforeUtcTicks;

		private static long _watcherRestartNotBeforeUtcTicks;

		internal static bool IsActive => _active;

		internal static bool IsBiomeRegistryReady => _biomeRegistryReady;

		internal static bool HasValidSnapshot
		{
			get
			{
				if (_active)
				{
					return _hasValidSnapshot;
				}
				return false;
			}
		}

		internal static void BeginServerSession()
		{
			if (_active || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			bool biomeRegistryReady = _biomeRegistryReady;
			EndServerSession();
			_active = true;
			_defaults = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
			_hasValidSnapshot = false;
			_templatePending = false;
			_biomeRegistryReady = biomeRegistryReady;
			_registryFallbackLogged = false;
			_registryFallbackNotBefore = Time.realtimeSinceStartup + 5f;
			_templateRetryNotBeforeUtc = DateTime.MinValue;
			_nextPollUtc = DateTime.UtcNow + PollingInterval;
			Interlocked.Exchange(ref _reloadRequested, 0);
			Interlocked.Exchange(ref _reloadAttempts, 0);
			Interlocked.Exchange(ref _watcherRestartRequested, 0);
			Interlocked.Exchange(ref _reloadNotBeforeUtcTicks, 0L);
			Interlocked.Exchange(ref _watcherRestartNotBeforeUtcTicks, 0L);
			_configurationDirectory = Path.Combine(Paths.ConfigPath, "PortalRules");
			_filePath = Path.Combine(_configurationDirectory, "admin-portal-biome-global-keys.yml");
			try
			{
				Directory.CreateDirectory(_configurationDirectory);
				_templatePending = !File.Exists(_filePath);
				try
				{
					StartWatcher();
				}
				catch (Exception ex)
				{
					StopWatcher();
					Interlocked.Exchange(ref _watcherRestartRequested, 1);
					ScheduleWatcherRestart(WatcherRestartRetryDelay);
					PortalRulesPlugin.PortalRulesLogger.LogError((object)("Failed to watch admin-portal-biome-global-keys.yml; periodic reload remains active: " + ex.Message));
				}
				bool changed;
				if (_templatePending)
				{
					PortalRulesPlugin.PortalRulesLogger.LogInfo((object)"admin-portal-biome-global-keys.yml will be generated after the biome registry is ready.");
				}
				else if (!TryReload(logOnlyWhenChanged: false, out changed))
				{
					ScheduleReload(ReloadRetryDelay);
				}
			}
			catch (Exception ex2)
			{
				StopWatcher();
				_active = false;
				_templatePending = false;
				PortalRulesPlugin.PortalRulesLogger.LogError((object)("Failed to initialize admin-portal-biome-global-keys.yml: " + ex2.Message));
			}
		}

		internal static bool EnsureTemplateReady()
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return false;
			}
			BeginServerSession();
			if (!_active)
			{
				return false;
			}
			if (!_templatePending)
			{
				if (_hasValidSnapshot || !File.Exists(_filePath))
				{
					return _hasValidSnapshot;
				}
				return TryReloadImmediately();
			}
			if (!File.Exists(_filePath) && DateTime.UtcNow < _templateRetryNotBeforeUtc)
			{
				return false;
			}
			string filePath = _filePath;
			try
			{
				bool flag = false;
				if (!File.Exists(filePath))
				{
					string content = BuildRegistryTemplate();
					flag = TryCreateFileWithoutOverwrite(filePath, content);
				}
				if (!_active || !string.Equals(_filePath, filePath, StringComparison.Ordinal) || !File.Exists(filePath))
				{
					return false;
				}
				_templatePending = false;
				_templateRetryNotBeforeUtc = DateTime.MinValue;
				if (flag)
				{
					PortalRulesPlugin.PortalRulesLogger.LogInfo((object)"Generated admin-portal-biome-global-keys.yml from the registered biome names.");
				}
				return TryReloadImmediately();
			}
			catch (Exception ex)
			{
				_templateRetryNotBeforeUtc = DateTime.UtcNow + ReloadRetryDelay;
				PortalRulesPlugin.PortalRulesLogger.LogError((object)("Failed to generate admin-portal-biome-global-keys.yml; it will remain pending until the next retry: " + ex.Message));
				return false;
			}
		}

		internal static void EndServerSession()
		{
			StopWatcher();
			_active = false;
			_defaults = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
			_hasValidSnapshot = false;
			_templatePending = false;
			_biomeRegistryReady = false;
			_registryFallbackLogged = false;
			_registryFallbackNotBefore = 0f;
			_templateRetryNotBeforeUtc = DateTime.MinValue;
			_nextPollUtc = DateTime.MinValue;
			_configurationDirectory = "";
			_filePath = "";
			Interlocked.Exchange(ref _reloadRequested, 0);
			Interlocked.Exchange(ref _reloadAttempts, 0);
			Interlocked.Exchange(ref _watcherRestartRequested, 0);
			Interlocked.Exchange(ref _reloadNotBeforeUtcTicks, 0L);
			Interlocked.Exchange(ref _watcherRestartNotBeforeUtcTicks, 0L);
		}

		internal static bool Tick()
		{
			TryCompleteBiomeRegistryFallback();
			if (!_active)
			{
				return false;
			}
			DateTime utcNow = DateTime.UtcNow;
			if (Volatile.Read(in _watcherRestartRequested) != 0 && utcNow.Ticks >= Interlocked.Read(in _watcherRestartNotBeforeUtcTicks))
			{
				Interlocked.Exchange(ref _watcherRestartRequested, 0);
				try
				{
					StartWatcher();
					RequestReload();
				}
				catch (Exception ex)
				{
					PortalRulesPlugin.PortalRulesLogger.LogError((object)("Failed to restart the admin-portal-biome-global-keys.yml watcher: " + ex.Message));
					Interlocked.Exchange(ref _watcherRestartRequested, 1);
					ScheduleWatcherRestart(WatcherRestartRetryDelay);
				}
			}
			if (_templatePending)
			{
				if (!File.Exists(_filePath))
				{
					if (_biomeRegistryReady && utcNow >= _templateRetryNotBeforeUtc)
					{
						bool hasValidSnapshot = _hasValidSnapshot;
						if (EnsureTemplateReady())
						{
							return !hasValidSnapshot;
						}
						return false;
					}
					return false;
				}
				_templatePending = false;
				ScheduleReload(TimeSpan.Zero);
			}
			if (utcNow >= _nextPollUtc)
			{
				_nextPollUtc = utcNow + PollingInterval;
				if (Volatile.Read(in _reloadRequested) == 0)
				{
					ScheduleReload(TimeSpan.Zero);
				}
			}
			if (Volatile.Read(in _reloadRequested) == 0 || utcNow.Ticks < Interlocked.Read(in _reloadNotBeforeUtcTicks))
			{
				return false;
			}
			Interlocked.Exchange(ref _reloadRequested, 0);
			if (TryReload(logOnlyWhenChanged: true, out var changed))
			{
				Interlocked.Exchange(ref _reloadAttempts, 0);
				return changed;
			}
			if (Interlocked.Increment(ref _reloadAttempts) <= 5)
			{
				ScheduleReload(ReloadRetryDelay);
			}
			return false;
		}

		private static void TryCompleteBiomeRegistryFallback()
		{
			if (!_biomeRegistryReady && !((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer() && !((Object)(object)ZoneSystem.instance == (Object)null) && !(Time.realtimeSinceStartup < _registryFallbackNotBefore))
			{
				if (!_registryFallbackLogged)
				{
					_registryFallbackLogged = true;
					PortalRulesPlugin.PortalRulesLogger.LogWarning((object)"The ZoneSystem biome-registry completion hook was not observed; using the currently registered biome names as a fallback.");
				}
				CompleteBiomeRegistryInitialization();
			}
		}

		private static void CompleteBiomeRegistryInitialization()
		{
			BeginServerSession();
			if (!_biomeRegistryReady)
			{
				_biomeRegistryReady = true;
				if (_active)
				{
					EnsureTemplateReady();
				}
				PublicPortalCatalog.RefreshAndBroadcast();
			}
		}

		internal static bool TryResolve(Vector3 position, out string requiredGlobalKey)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: 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)
			requiredGlobalKey = "";
			if (!_active || !_hasValidSnapshot || WorldGenerator.instance == null)
			{
				return false;
			}
			Biome biome = WorldGenerator.instance.GetBiome(position);
			string name = Enum.GetName(typeof(Biome), biome);
			if (!string.IsNullOrWhiteSpace(name))
			{
				return _defaults.TryGetValue(name.Trim(), out requiredGlobalKey);
			}
			return false;
		}

		private static string BuildRegistryTemplate()
		{
			return BuildRegistryTemplate(Enum.GetNames(typeof(Biome)));
		}

		private static string BuildRegistryTemplate(string[] registeredNames)
		{
			if (registeredNames.Length > 4096)
			{
				throw new InvalidDataException($"biome registry exceeds {4096} entries");
			}
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
			for (int i = 0; i < registeredNames.Length; i++)
			{
				string text = (registeredNames[i] ?? "").Trim();
				if (!string.Equals(text, "None", StringComparison.OrdinalIgnoreCase) && !string.Equals(text, "All", StringComparison.OrdinalIgnoreCase))
				{
					try
					{
						ValidateBiomeName(text);
					}
					catch (InvalidDataException)
					{
						string value = ((text.Length <= 64) ? text : (text.Substring(0, 64) + "..."));
						PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("Skipped invalid registered biome name " + FormatYamlKey(value) + " while generating admin-portal-biome-global-keys.yml."));
						continue;
					}
					if (!dictionary.TryGetValue(text, out var value2) || string.CompareOrdinal(text, value2) < 0)
					{
						dictionary[text] = text;
					}
				}
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("# PortalRules default GlobalKey requirements for newly initialized Admin portals.");
			stringBuilder.AppendLine("# This file is generated once from the server's registered biome names and is");
			stringBuilder.AppendLine("# never automatically edited. Delete it before the next server session to rebuild it.");
			stringBuilder.AppendLine("# Biome names are case-insensitive. Expand World Data custom biomes use the stable");
			stringBuilder.AppendLine("# `biome:` name from its biome YAML, not a translated name or numeric biome value.");
			stringBuilder.AppendLine("# The biome is resolved from each portal's actual world position.");
			stringBuilder.AppendLine("# A RequiredGlobalKey already stored in the portal ZDO wins over this default.");
			stringBuilder.AppendLine("# This includes InfinityHammer blueprint data and EWD objectData/locationObjectData.");
			stringBuilder.AppendLine("# An explicitly stored empty RequiredGlobalKey suppresses the biome default.");
			stringBuilder.AppendLine("# With YouAreNotWorthy, the selected key is checked per character; otherwise it");
			stringBuilder.AppendLine("# is checked against the world's shared GlobalKeys.");
			stringBuilder.AppendLine("# An empty value means that biome has no default required GlobalKey.");
			stringBuilder.AppendLine("# Reloads affect only Admin portals whose initial authority is resolved afterwards.");
			stringBuilder.Append("format_version: ").AppendLine(1.ToString(CultureInfo.InvariantCulture));
			stringBuilder.AppendLine("biomes:");
			KeyValuePair<string, string>[] vanillaTemplate = VanillaTemplate;
			for (int i = 0; i < vanillaTemplate.Length; i++)
			{
				KeyValuePair<string, string> keyValuePair = vanillaTemplate[i];
				dictionary.Remove(keyValuePair.Key);
				AppendBiome(stringBuilder, keyValuePair.Key, keyValuePair.Value);
			}
			List<string> list = new List<string>(dictionary.Values);
			list.Sort(CompareBiomeNames);
			if (VanillaTemplate.Length + list.Count > 4096)
			{
				throw new InvalidDataException($"generated biome list exceeds {4096} entries");
			}
			foreach (string item in list)
			{
				AppendBiome(stringBuilder, item, "");
			}
			string text2 = stringBuilder.ToString();
			if ((long)Encoding.UTF8.GetByteCount(text2) > 524288L)
			{
				throw new InvalidDataException($"generated template exceeds {524288L} bytes");
			}
			return text2;
		}

		private static int CompareBiomeNames(string left, string right)
		{
			int num = StringComparer.OrdinalIgnoreCase.Compare(left, right);
			if (num == 0)
			{
				return StringComparer.Ordinal.Compare(left, right);
			}
			return num;
		}

		private static void AppendBiome(StringBuilder yaml, string biomeName, string requiredGlobalKey)
		{
			yaml.Append("  ").Append(FormatYamlKey(biomeName)).Append(':');
			if (requiredGlobalKey.Length != 0)
			{
				yaml.Append(' ').Append(requiredGlobalKey);
			}
			yaml.AppendLine();
		}

		private static string FormatYamlKey(string value)
		{
			if (IsSafePlainYamlKey(value))
			{
				return value;
			}
			StringBuilder stringBuilder = new StringBuilder(value.Length + 2);
			stringBuilder.Append('"');
			foreach (char c in value)
			{
				switch (c)
				{
				case '\\':
					stringBuilder.Append("\\\\");
					continue;
				case '"':
					stringBuilder.Append("\\\"");
					continue;
				case '\u2028':
				case '\u2029':
				{
					StringBuilder stringBuilder2 = stringBuilder.Append("\\u");
					int num = c;
					stringBuilder2.Append(num.ToString("X4", CultureInfo.InvariantCulture));
					continue;
				}
				}
				if (char.IsControl(c))
				{
					StringBuilder stringBuilder3 = stringBuilder.Append("\\u");
					int num = c;
					stringBuilder3.Append(num.ToString("X4", CultureInfo.InvariantCulture));
				}
				else
				{
					stringBuilder.Append(c);
				}
			}
			return stringBuilder.Append('"').ToString();
		}

		private static bool IsSafePlainYamlKey(string value)
		{
			if (value.Length == 0 || AmbiguousPlainYamlScalars.Contains(value) || (!char.IsLetter(value[0]) && value[0] != '_'))
			{
				return false;
			}
			foreach (char c in value)
			{
				if (!char.IsLetterOrDigit(c) && c != '_' && c != '-')
				{
					return false;
				}
			}
			return true;
		}

		private static bool TryCreateFileWithoutOverwrite(string path, string content)
		{
			string text = Path.Combine(Path.GetDirectoryName(path) ?? throw new InvalidOperationException("Configuration directory is unavailable."), "." + Path.GetFileName(path) + "." + Guid.NewGuid().ToString("N") + ".pending");
			try
			{
				PortalAccountStore.WriteAtomicFile(text, content, null);
				try
				{
					File.Move(text, path);
					return true;
				}
				catch (IOException) when (File.Exists(path))
				{
					return false;
				}
			}
			finally
			{
				if (File.Exists(text))
				{
					File.Delete(text);
				}
			}
		}

		private static bool TryReloadImmediately()
		{
			Interlocked.Exchange(ref _reloadRequested, 0);
			Interlocked.Exchange(ref _reloadAttempts, 0);
			if (TryReload(logOnlyWhenChanged: false, out var _))
			{
				_nextPollUtc = DateTime.UtcNow + PollingInterval;
				return true;
			}
			ScheduleReload(ReloadRetryDelay);
			return false;
		}

		private static bool TryReload(bool logOnlyWhenChanged, out bool changed)
		{
			changed = false;
			if (!File.Exists(_filePath))
			{
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)"admin-portal-biome-global-keys.yml is missing; retaining the last valid biome defaults. Use 'biomes: {}' to clear them.");
				return false;
			}
			try
			{
				if (new FileInfo(_filePath).Length > 524288)
				{
					throw new InvalidDataException($"file exceeds {524288L} bytes");
				}
				BiomeDefaultsYaml biomeDefaultsYaml = Deserializer.Deserialize<BiomeDefaultsYaml>(File.ReadAllText(_filePath));
				if (biomeDefaultsYaml == null || biomeDefaultsYaml.FormatVersion != 1 || biomeDefaultsYaml.Biomes == null)
				{
					throw new InvalidDataException($"format_version must be {1} and biomes must be present");
				}
				if (biomeDefaultsYaml.Biomes.Count > 4096)
				{
					throw new InvalidDataException($"biomes exceeds {4096} entries");
				}
				Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
				foreach (KeyValuePair<string, string> biome in biomeDefaultsYaml.Biomes)
				{
					string text = (biome.Key ?? "").Trim();
					ValidateBiomeName(text);
					if (!PublicPortalData.TryNormalizeRequiredGlobalKey(biome.Value, out string normalized, out RequiredGlobalKeyValidationFailure failure))
					{
						throw new InvalidDataException($"GlobalKey for biome '{text}' is invalid ({failure})");
					}
					if (dictionary.ContainsKey(text))
					{
						throw new InvalidDataException("biome '" + text + "' is duplicated after case and whitespace normalization");
					}
					dictionary.Add(text, normalized);
				}
				changed = !_hasValidSnapshot || !DictionariesEqual(_defaults, dictionary);
				_defaults = dictionary;
				_hasValidSnapshot = true;
				if (!logOnlyWhenChanged | changed)
				{
					PortalRulesPlugin.PortalRulesLogger.LogInfo((object)$"Loaded {_defaults.Count} Admin portal biome GlobalKey default(s).");
				}
				return true;
			}
			catch (Exception ex)
			{
				PortalRulesPlugin.PortalRulesLogger.LogError((object)("Failed to reload admin-portal-biome-global-keys.yml; retaining the last valid biome defaults: " + ex.Message));
				return false;
			}
		}

		private static void ValidateBiomeName(string biomeName)
		{
			if (biomeName.Length == 0)
			{
				throw new InvalidDataException("biome names must not be empty");
			}
			if (biomeName.Length > 128)
			{
				throw new InvalidDataException($"biome name '{biomeName}' exceeds {128} characters");
			}
			for (int i = 0; i < biomeName.Length; i++)
			{
				if (char.IsControl(biomeName[i]))
				{
					throw new InvalidDataException("biome name '" + biomeName + "' contains control characters");
				}
			}
			if (long.TryParse(biomeName, NumberStyles.Integer, CultureInfo.InvariantCulture, out var _))
			{
				throw new InvalidDataException("biome '" + biomeName + "' is numeric; use its stable biome name instead");
			}
		}

		private static bool DictionariesEqual(Dictionary<string, string> left, Dictionary<string, string> right)
		{
			if (left.Count != right.Count)
			{
				return false;
			}
			foreach (KeyValuePair<string, string> item in left)
			{
				if (!right.TryGetValue(item.Key, out string value) || !string.Equals(value, item.Value, StringComparison.Ordinal))
				{
					return false;
				}
			}
			return true;
		}

		private static void StartWatcher()
		{
			StopWatcher();
			_watcher = new FileSystemWatcher(_configurationDirectory, "admin-portal-biome-global-keys.yml")
			{
				IncludeSubdirectories = false,
				NotifyFilter = (NotifyFilters.FileName | NotifyFilters.Size | NotifyFilters.LastWrite)
			};
			_watcher.Changed += OnFileChanged;
			_watcher.Created += OnFileChanged;
			_watcher.Deleted += OnFileChanged;
			_watcher.Renamed += OnFileRenamed;
			_watcher.Error += OnWatcherError;
			_watcher.EnableRaisingEvents = true;
		}

		private static void StopWatcher()
		{
			if (_watcher != null)
			{
				_watcher.EnableRaisingEvents = false;
				_watcher.Changed -= OnFileChanged;
				_watcher.Created -= OnFileChanged;
				_watcher.Deleted -= OnFileChanged;
				_watcher.Renamed -= OnFileRenamed;
				_watcher.Error -= OnWatcherError;
				_watcher.Dispose();
				_watcher = null;
			}
		}

		private static void OnFileChanged(object sender, FileSystemEventArgs args)
		{
			RequestReload();
		}

		private static void OnFileRenamed(object sender, RenamedEventArgs args)
		{
			RequestReload();
		}

		private static void OnWatcherError(object sender, ErrorEventArgs args)
		{
			PortalRulesPlugin.PortalRulesLogger.LogError((object)("The admin-portal-biome-global-keys.yml watcher failed and will be restarted: " + args.GetException().Message));
			Interlocked.Exchange(ref _watcherRestartRequested, 1);
			ScheduleWatcherRestart(WatcherRestartRetryDelay);
			RequestReload();
		}

		private static void RequestReload()
		{
			Interlocked.Exchange(ref _reloadAttempts, 0);
			ScheduleReload(ReloadDebounce);
		}

		private static void ScheduleReload(TimeSpan delay)
		{
			Interlocked.Exchange(ref _reloadNotBeforeUtcTicks, (DateTime.UtcNow + delay).Ticks);
			Interlocked.Exchange(ref _reloadRequested, 1);
		}

		private static void ScheduleWatcherRestart(TimeSpan delay)
		{
			Interlocked.Exchange(ref _watcherRestartNotBeforeUtcTicks, (DateTime.UtcNow + delay).Ticks);
		}
	}
	[HarmonyPatch]
	internal static class AdminPortalPrefabManager
	{
		[HarmonyPatch(typeof(Game), "Awake")]
		private static class GameAwakePatch
		{
			private static void Postfix(Game __instance)
			{
				RegisterPortalHashes(__instance);
			}
		}

		[HarmonyPatch(typeof(TeleportWorld), "UpdatePortal")]
		private static class ShowAdminPortalWhirlingEffectNearbyPatch
		{
			[HarmonyPriority(0)]
			private static void Postfix(TeleportWorld __instance)
			{
				//IL_0064: Unknown result type (might be due to invalid IL or missing references)
				ZDO portalZdo = PublicPortalKinds.GetPortalZdo(__instance);
				if (portalZdo != null && PublicPortalKinds.IsAdminPortalPrefab(portalZdo.GetPrefab()))
				{
					EffectFade target_found = __instance.m_target_found;
					if ((Object)(object)target_found != (Object)null)
					{
						Player localPlayer = Player.m_localPlayer;
						Transform val = (((Object)(object)__instance.m_proximityRoot != (Object)null) ? __instance.m_proximityRoot : ((Component)__instance).transform);
						float num = Mathf.Max(0f, __instance.m_activationRange);
						bool active = (Object)(object)localPlayer != (Object)null && (Object)(object)Player.GetClosestPlayer(val.position, num) != (Object)null;
						target_found.SetActive(active);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Piece), "Awake")]
		private static class ClearAdminPortalPieceCreatorPatch
		{
			private static void Postfix(Piece __instance, ref long ___m_creator)
			{
				if (IsAdminPortalPiece(__instance))
				{
					___m_creator = 0L;
					if (!ZNetView.m_forceDisableInit)
					{
						DisablePlacedPortalSolidColliders(((Component)__instance).gameObject);
						HidePlacedPortalMeshes(((Component)__instance).gameObject);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Piece), "SetCreator")]
		private static class BlockAdminPortalPieceCreatorPatch
		{
			private static bool Prefix(Piece __instance)
			{
				return !IsAdminPortalPiece(__instance);
			}
		}

		[HarmonyPatch(typeof(PieceTable), "UpdateAvailable")]
		private static class AdminPortalBuildMenuVisibilityPatch
		{
			[HarmonyPriority(0)]
			private static void Postfix(PieceTable __instance, Player player, List<List<Piece>> ___m_availablePieces)
			{
				foreach (List<Piece> ___m_availablePiece in ___m_availablePieces)
				{
					___m_availablePiece.RemoveAll(IsAdminPortalPiece);
				}
				if ((Object)(object)player != (Object)(object)Player.m_localPlayer || !PortalRulesPlugin.HasAdminDebugAccess)
				{
					return;
				}
				int num = 0;
				if (num < 0 || num >= ___m_availablePieces.Count)
				{
					return;
				}
				List<Piece> list = ___m_availablePieces[num];
				foreach (GameObject piece in __instance.m_pieces)
				{
					Piece val = (((Object)(object)piece != (Object)null) ? piece.GetComponent<Piece>() : null);
					if ((Object)(object)val != (Object)null && IsAdminPortalPiece(val) && !list.Contains(val))
					{
						list.Add(val);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Player), "TryPlacePiece")]
		private static class AdminPortalPlacementAccessPatch
		{
			private static bool Prefix(Player __instance, Piece piece, ref bool __result)
			{
				if (!IsAdminPortalPiece(piece))
				{
					return true;
				}
				if ((Object)(object)__instance == (Object)(object)Player.m_localPlayer && PortalRulesPlugin.HasAdminDebugAccess)
				{
					return true;
				}
				if (__instance != null)
				{
					((Character)__instance).Message((MessageType)2, new PortalRulesMessage("$sighsorry_portalrules_admin_portal_placement_requires_admin_debug").Localize(), 0, (Sprite)null);
				}
				__result = false;
				return false;
			}
		}

		private readonly struct PortalCloneSpec
		{
			internal readonly string SourcePrefabName;

			internal readonly string TargetPrefabName;

			internal readonly string DisplayName;

			internal PortalCloneSpec(string sourcePrefabName, string targetPrefabName, string displayName)
			{
				SourcePrefabName = sourcePrefabName;
				TargetPrefabName = targetPrefabName;
				DisplayName = displayName;
			}
		}

		private static readonly PortalCloneSpec[] PortalCloneSpecs = new PortalCloneSpec[2]
		{
			new PortalCloneSpec("portal_wood", "admin_portal_wood", "$sighsorry_portalrules_admin_wood_portal_name"),
			new PortalCloneSpec("portal_stone", "admin_portal_stone", "$sighsorry_portalrules_admin_stone_portal_name")
		};

		private static bool _registered;

		private static Player? _lastBuildMenuPlayer;

		private static bool _lastBuildMenuAccess;

		private static bool _buildMenuAccessInitialized;

		private static readonly MethodInfo? UpdateAvailablePiecesMethod = AccessTools.DeclaredMethod(typeof(Player), "UpdateAvailablePiecesList", (Type[])null, (Type[])null);

		internal static void Initialize()
		{
			PrefabManager.OnVanillaPrefabsAvailable += RegisterAdminPortals;
			PieceManager.OnPiecesRegistered += RegisterAdminPortalPieces;
		}

		internal static void Shutdown()
		{
			PrefabManager.OnVanillaPrefabsAvailable -= RegisterAdminPortals;
			PieceManager.OnPiecesRegistered -= RegisterAdminPortalPieces;
			_lastBuildMenuPlayer = null;
			_lastBuildMenuAccess = false;
			_buildMenuAccessInitialized = false;
		}

		internal static void Tick()
		{
			Player localPlayer = Player.m_localPlayer;
			if (!_registered || (Object)(object)localPlayer == (Object)null)
			{
				_lastBuildMenuPlayer = null;
				_buildMenuAccessInitialized = false;
				return;
			}
			bool hasAdminDebugAccess = PortalRulesPlugin.HasAdminDebugAccess;
			if (_buildMenuAccessInitialized && _lastBuildMenuPlayer == localPlayer && _lastBuildMenuAccess == hasAdminDebugAccess)
			{
				return;
			}
			_lastBuildMenuPlayer = localPlayer;
			_lastBuildMenuAccess = hasAdminDebugAccess;
			_buildMenuAccessInitialized = true;
			if (!((Character)localPlayer).InPlaceMode())
			{
				return;
			}
			if (UpdateAvailablePiecesMethod == null)
			{
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)"Could not refresh the Hammer piece list after admin build access changed.");
				return;
			}
			try
			{
				UpdateAvailablePiecesMethod.Invoke(localPlayer, Array.Empty<object>());
			}
			catch (Exception ex)
			{
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("Could not refresh the Hammer piece list after admin build access changed: " + ex.GetBaseException().Message));
			}
		}

		private static void RegisterAdminPortals()
		{
			if (_registered)
			{
				PrefabManager.OnVanillaPrefabsAvailable -= RegisterAdminPortals;
				return;
			}
			int num = 0;
			PortalCloneSpec[] portalCloneSpecs = PortalCloneSpecs;
			for (int i = 0; i < portalCloneSpecs.Length; i++)
			{
				PortalCloneSpec portalCloneSpec = portalCloneSpecs[i];
				GameObject prefab = PrefabManager.Instance.GetPrefab(portalCloneSpec.TargetPrefabName);
				if ((Object)(object)prefab != (Object)null)
				{
					num++;
					continue;
				}
				GameObject prefab2 = PrefabManager.Instance.GetPrefab(portalCloneSpec.SourcePrefabName);
				Piece sourcePiece = ((prefab2 != null) ? prefab2.GetComponent<Piece>() : null);
				prefab = PrefabManager.Instance.CreateClonedPrefab(portalCloneSpec.TargetPrefabName, portalCloneSpec.SourcePrefabName);
				if ((Object)(object)prefab == (Object)null)
				{
					PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("Could not clone '" + portalCloneSpec.SourcePrefabName + "' into '" + portalCloneSpec.TargetPrefabName + "'."));
				}
				else
				{
					PrepareAdminPortal(prefab, sourcePiece, portalCloneSpec.DisplayName);
					PrefabManager.Instance.AddPrefab(prefab);
					num++;
				}
			}
			if (num == PortalCloneSpecs.Length)
			{
				_registered = true;
				PrefabManager.OnVanillaPrefabsAvailable -= RegisterAdminPortals;
				PortalRulesPlugin.PortalRulesLogger.LogInfo((object)"Registered admin portal prefabs: admin_portal_wood, admin_portal_stone.");
			}
		}

		private static void RegisterAdminPortalPieces()
		{
			int num = 0;
			PortalCloneSpec[] portalCloneSpecs = PortalCloneSpecs;
			for (int i = 0; i < portalCloneSpecs.Length; i++)
			{
				PortalCloneSpec portalCloneSpec = portalCloneSpecs[i];
				GameObject prefab = PrefabManager.Instance.GetPrefab(portalCloneSpec.TargetPrefabName);
				if ((Object)(object)prefab == (Object)null)
				{
					PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("Could not find admin portal '" + portalCloneSpec.TargetPrefabName + "' for Hammer registration."));
					continue;
				}
				try
				{
					PieceManager.Instance.RegisterPieceInPieceTable(prefab, PieceTables.Hammer, PieceCategories.Misc);
					num++;
				}
				catch (Exception ex)
				{
					PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("Could not add admin portal '" + portalCloneSpec.TargetPrefabName + "' to the Hammer piece table: " + ex.Message));
				}
			}
			if (num == PortalCloneSpecs.Length)
			{
				PortalRulesPlugin.PortalRulesLogger.LogInfo((object)"Registered admin portal pieces in the Hammer Misc category.");
			}
		}

		private static void PrepareAdminPortal(GameObject prefab, Piece? sourcePiece, string displayName)
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			PrepareAdminPiece(prefab, sourcePiece, displayName);
			RemoveRootComponent<WearNTear>(prefab);
			TeleportWorld component = prefab.GetComponent<TeleportWorld>();
			if ((Object)(object)component != (Object)null)
			{
				((Behaviour)component).enabled = true;
				component.m_allowAllItems = true;
				component.m_proximityRoot = (((Object)(object)component.m_proximityRoot != (Object)null) ? component.m_proximityRoot : prefab.transform);
				EnsureTargetFoundEffect(prefab, component);
				EnsureModelRenderer(prefab, component);
			}
			ZNetView component2 = prefab.GetComponent<ZNetView>();
			if ((Object)(object)component2 != (Object)null)
			{
				component2.m_persistent = true;
				component2.m_distant = false;
				component2.m_type = (ObjectType)2;
			}
			EnsureInteractionTrigger(prefab);
		}

		private static void PrepareAdminPiece(GameObject prefab, Piece? sourcePiece, string displayName)
		{
			//IL_0085: 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)
			Piece component = prefab.GetComponent<Piece>();
			if ((Object)(object)component == (Object)null)
			{
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("Admin portal '" + ((Object)prefab).name + "' has no Piece metadata; its icon cannot be displayed."));
				return;
			}
			if ((Object)(object)sourcePiece?.m_icon != (Object)null)
			{
				component.m_icon = sourcePiece.m_icon;
			}
			else
			{
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("Admin portal '" + ((Object)prefab).name + "' could not reuse its source portal icon."));
			}
			component.m_name = displayName;
			component.m_description = "$sighsorry_portalrules_admin_portal_description";
			component.m_category = (PieceCategory)0;
			component.m_enabled = false;
			component.m_canBeRemoved = false;
			component.m_craftingStation = null;
			component.m_resources = Array.Empty<Requirement>();
			component.m_destroyedLootPrefab = null;
			component.m_comfort = 0;
			component.m_comfortGroup = (ComfortGroup)0;
			component.m_comfortObject = null;
			component.m_harvest = false;
			((StaticTarget)component).m_primaryTarget = false;
			((StaticTarget)component).m_randomTarget = false;
			component.m_targetNonPlayerBuilt = false;
		}

		private static bool IsAdminPortalPiece(Piece piece)
		{
			if ((Object)(object)piece == (Object)null)
			{
				return false;
			}
			string prefabName = Utils.GetPrefabName(((Component)piece).gameObject);
			if (!(prefabName == "admin_portal_wood"))
			{
				return prefabName == "admin_portal_stone";
			}
			return true;
		}

		private static void EnsureInteractionTrigger(GameObject prefab)
		{
			//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_0058: 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_0071: 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_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)prefab.transform.Find("ADMIN_INTERACT") != (Object)null))
			{
				Collider val = FindTeleportCollider(prefab);
				Transform val2 = (((Object)(object)val != (Object)null) ? ((Component)val).transform : prefab.transform);
				GameObject val3 = new GameObject("ADMIN_INTERACT")
				{
					layer = LayerOrFallback("piece_nonsolid", prefab.layer)
				};
				val3.transform.SetParent(prefab.transform, false);
				val3.transform.localPosition = val2.localPosition;
				val3.transform.localRotation = val2.localRotation;
				val3.transform.localScale = val2.localScale;
				BoxCollider val4 = val3.AddComponent<BoxCollider>();
				((Collider)val4).isTrigger = true;
				BoxCollider val5 = (BoxCollider)(object)((val is BoxCollider) ? val : null);
				if (val5 != null)
				{
					val4.center = val5.center;
					val4.size = val5.size;
				}
				else
				{
					val4.center = new Vector3(0f, 1.5f, 0f);
					val4.size = new Vector3(2f, 3f, 0.5f);
				}
			}
		}

		private static Collider FindTeleportCollider(GameObject prefab)
		{
			Collider[] componentsInChildren = prefab.GetComponentsInChildren<Collider>(true);
			foreach (Collider val in componentsInChildren)
			{
				if ((Object)(object)((Component)val).GetComponent<TeleportWorldTrigger>() != (Object)null)
				{
					return val;
				}
			}
			return null;
		}

		private static void DisablePlacedPortalSolidColliders(GameObject portal)
		{
			Collider[] componentsInChildren = portal.GetComponentsInChildren<Collider>(true);
			foreach (Collider val in componentsInChildren)
			{
				if (!val.isTrigger)
				{
					val.enabled = false;
				}
			}
		}

		private static void HidePlacedPortalMeshes(GameObject portal)
		{
			TeleportWorld component = portal.GetComponent<TeleportWorld>();
			object obj;
			if (component == null)
			{
				obj = null;
			}
			else
			{
				EffectFade target_found = component.m_target_found;
				obj = ((target_found != null) ? ((Component)target_found).transform : null);
			}
			Transform val = (Transform)obj;
			MeshRenderer[] componentsInChildren = portal.GetComponentsInChildren<MeshRenderer>(true);
			foreach (MeshRenderer val2 in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null || !((Component)val2).transform.IsChildOf(val))
				{
					((Renderer)val2).enabled = false;
				}
			}
			SkinnedMeshRenderer[] componentsInChildren2 = portal.GetComponentsInChildren<SkinnedMeshRenderer>(true);
			foreach (SkinnedMeshRenderer val3 in componentsInChildren2)
			{
				if ((Object)(object)val == (Object)null || !((Component)val3).transform.IsChildOf(val))
				{
					((Renderer)val3).enabled = false;
				}
			}
		}

		private static void EnsureTargetFoundEffect(GameObject prefab, TeleportWorld teleportWorld)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			if (!((Object)(object)teleportWorld.m_target_found != (Object)null))
			{
				GameObject val = new GameObject("ADMIN_TARGET_FOUND_DUMMY");
				val.transform.SetParent(prefab.transform, false);
				teleportWorld.m_target_found = val.AddComponent<EffectFade>();
			}
		}

		private static void EnsureModelRenderer(GameObject prefab, TeleportWorld teleportWorld)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)teleportWorld.m_model != (Object)null))
			{
				MeshRenderer val = prefab.GetComponentInChildren<MeshRenderer>(true);
				if ((Object)(object)val == (Object)null)
				{
					GameObject obj = GameObject.CreatePrimitive((PrimitiveType)3);
					((Object)obj).name = "ADMIN_MODEL_DUMMY";
					obj.transform.SetParent(prefab.transform, false);
					obj.transform.localScale = Vector3.one * 0.1f;
					RemoveRootComponent<Collider>(obj);
					val = obj.GetComponent<MeshRenderer>();
				}
				teleportWorld.m_model = val;
			}
		}

		private static int LayerOrFallback(string layerName, int fallback)
		{
			int num = LayerMask.NameToLayer(layerName);
			if (num < 0)
			{
				return fallback;
			}
			return num;
		}

		private static void RemoveRootComponent<T>(GameObject gameObject) where T : Component
		{
			T component = gameObject.GetComponent<T>();
			if ((Object)(object)component != (Object)null)
			{
				Object.DestroyImmediate((Object)(object)component);
			}
		}

		internal static void RegisterPortalHashes(Game game)
		{
			PortalCloneSpec[] portalCloneSpecs = PortalCloneSpecs;
			for (int i = 0; i < portalCloneSpecs.Length; i++)
			{
				int stableHashCode = StringExtensionMethods.GetStableHashCode(portalCloneSpecs[i].TargetPrefabName);
				if (!game.PortalPrefabHash.Contains(stableHashCode))
				{
					game.PortalPrefabHash.Add(stableHashCode);
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class AdminPortalOperations
	{
		private sealed class RequiredGlobalKeyTextReceiver : TextReceiver
		{
			private readonly ZDOID _portalId;

			private readonly string _currentValue;

			internal RequiredGlobalKeyTextReceiver(ZDOID portalId, string currentValue)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				_portalId = portalId;
				_currentValue = currentValue ?? "";
			}

			public string GetText()
			{
				return _currentValue;
			}

			public void SetText(string text)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				RequestRequiredGlobalKeyChange(_portalId, text);
			}
		}

		[HarmonyPatch(typeof(TeleportWorld), "SetText")]
		private static class AdminPortalSetTextPatch
		{
			private static bool Prefix(TeleportWorld __instance, string text)
			{
				ZDO portalZdo = PublicPortalKinds.GetPortalZdo(__instance);
				if (portalZdo == null || !PublicPortalInteraction.IsAdminPortal(portalZdo))
				{
					return true;
				}
				RequestTagChange(__instance, text);
				return false;
			}
		}

		[HarmonyPatch(typeof(TeleportWorld), "RPC_SetTag", new Type[]
		{
			typeof(long),
			typeof(string),
			typeof(string)
		})]
		private static class BlockVanillaAdminPortalTagRpcPatch
		{
			private static bool Prefix(TeleportWorld __instance)
			{
				ZDO portalZdo = PublicPortalKinds.GetPortalZdo(__instance);
				if (portalZdo != null)
				{
					return !PublicPortalInteraction.IsAdminPortal(portalZdo);
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(Player), "RemovePiece")]
		private static class AdminPortalRemovalPatch
		{
			private static bool Prefix(Player __instance, ref bool __result)
			{
				if ((Object)(object)__instance == (Object)null || (Object)(object)__instance != (Object)(object)Player.m_localPlayer || !TryGetAimedAdminPortal(__instance, out ZDO zdo))
				{
					return true;
				}
				if (!PortalRulesPlugin.HasAdminDebugAccess)
				{
					ShowOperationMessage(new PortalRulesMessage("$sighsorry_portalrules_admin_portal_dismantling_requires_admin_debug"));
					__result = false;
					return false;
				}
				RequestRemoval(zdo);
				__result = false;
				return false;
			}

			private static bool TryGetAimedAdminPortal(Player player, out ZDO zdo)
			{
				//IL_001a: 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_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				zdo = null;
				RaycastHit val = default(RaycastHit);
				if ((Object)(object)GameCamera.instance == (Object)null || !Physics.Raycast(((Component)GameCamera.instance).transform.position, ((Component)GameCamera.instance).transform.forward, ref val, 50f, AdminRemoveRayMask, (QueryTriggerInteraction)2) || Vector3.Distance(((RaycastHit)(ref val)).point, ((Character)player).GetEyePoint()) >= player.m_maxPlaceDistance)
				{
					return false;
				}
				TeleportWorld componentInParent = ((Component)((RaycastHit)(ref val)).collider).GetComponentInParent<TeleportWorld>();
				ZDO val2 = (((Object)(object)componentInParent != (Object)null) ? PublicPortalKinds.GetPortalZdo(componentInParent) : null);
				if (val2 == null || !PublicPortalInteraction.IsAdminPortal(val2))
				{
					return false;
				}
				zdo = val2;
				return true;
			}
		}

		private const float AdminOperationCooldownSeconds = 0.25f;

		private const int MaximumPortalTagLength = 10;

		private static readonly Dictionary<ZRpc, float> LastAdminOperationAt = new Dictionary<ZRpc, float>();

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

		internal static void Shutdown()
		{
			LastAdminOperationAt.Clear();
		}

		internal static void RegisterPeer(ZNet znet, ZNetPeer peer)
		{
			if (!((Object)(object)znet == (Object)null) && peer?.m_rpc != null && znet.IsServer())
			{
				peer.m_rpc.Register<ZDOID, string, bool>("sighsorry.PortalRules.ChangeAdminPortalTag.v1", (Action<ZRpc, ZDOID, string, bool>)OnRemoteTagChange);
				peer.m_rpc.Register<ZDOID, string, bool>("sighsorry.PortalRules.ChangeAdminPortalRequiredGlobalKey.v1", (Action<ZRpc, ZDOID, string, bool>)OnRemoteRequiredGlobalKeyChange);
				peer.m_rpc.Register<ZDOID, bool>("sighsorry.PortalRules.RemoveAdminPortal.v1", (Action<ZRpc, ZDOID, bool>)OnRemoteRemoval);
			}
		}

		internal static void ForgetPeer(ZRpc rpc)
		{
			if (rpc != null)
			{
				LastAdminOperationAt.Remove(rpc);
			}
		}

		private static void RequestTagChange(TeleportWorld portal, string tag)
		{
			//IL_004e: 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)
			ZDO portalZdo = PublicPortalKinds.GetPortalZdo(portal);
			if (portalZdo == null)
			{
				ShowOperationMessage(new PortalRulesMessage("$sighsorry_portalrules_admin_portal_unavailable"));
				return;
			}
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				ShowOperationMessage(new PortalRulesMessage("$sighsorry_portalrules_server_unavailable"));
				return;
			}
			if (ZNet.instance.IsServer())
			{
				TryApplyTagChange(portalZdo.m_uid, tag, null, PortalRulesPlugin.IsAdmin, Player.m_debugMode, out var message);
				ShowOperationMessage(message);
				return;
			}
			ZRpc serverRPC = ZNet.instance.GetServerRPC();
			if (serverRPC == null)
			{
				ShowOperationMessage(new PortalRulesMessage("$sighsorry_portalrules_server_connection_unavailable"));
				return;
			}
			serverRPC.Invoke("sighsorry.PortalRules.ChangeAdminPortalTag.v1", new object[3]
			{
				portalZdo.m_uid,
				tag ?? "",
				Player.m_debugMode
			});
		}

		private static void RequestRemoval(ZDO zdo)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				ShowOperationMessage(new PortalRulesMessage("$sighsorry_portalrules_server_unavailable"));
				return;
			}
			if (ZNet.instance.IsServer())
			{
				TryApplyRemoval(zdo.m_uid, null, PortalRulesPlugin.IsAdmin, Player.m_debugMode, out var message);
				ShowOperationMessage(message);
				return;
			}
			ZRpc serverRPC = ZNet.instance.GetServerRPC();
			if (serverRPC == null)
			{
				ShowOperationMessage(new PortalRulesMessage("$sighsorry_portalrules_server_connection_unavailable"));
				return;
			}
			serverRPC.Invoke("sighsorry.PortalRules.RemoveAdminPortal.v1", new object[2]
			{
				zdo.m_uid,
				Player.m_debugMode
			});
		}

		internal static void OpenRequiredGlobalKeyInput(TeleportWorld portal)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			ZDO portalZdo = PublicPortalKinds.GetPortalZdo(portal);
			if (portalZdo == null)
			{
				ShowOperationMessage(new PortalRulesMessage("$sighsorry_portalrules_admin_portal_unavailable"));
				return;
			}
			TextInput instance = TextInput.instance;
			if ((Object)(object)instance == (Object)null)
			{
				ShowOperationMessage(new PortalRulesMessage("$sighsorry_portalrules_text_input_unavailable"));
			}
			else
			{
				instance.RequestText((TextReceiver)(object)new RequiredGlobalKeyTextReceiver(portalZdo.m_uid, PublicPortalCatalog.GetEffectiveRequiredGlobalKey(portalZdo)), new PortalRulesMessage("$sighsorry_portalrules_required_global_key_input_title").Localize(), 128);
			}
		}

		private static void RequestRequiredGlobalKeyChange(ZDOID portalId, string requiredGlobalKey)
		{
			//IL_0035: 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)
			if ((Object)(object)ZNet.instance == (Object)null || ZDOMan.instance == null)
			{
				ShowOperationMessage(new PortalRulesMessage("$sighsorry_portalrules_server_unavailable"));
				return;
			}
			if (ZNet.instance.IsServer())
			{
				TryApplyRequiredGlobalKeyChange(portalId, requiredGlobalKey, null, PortalRulesPlugin.IsAdmin, Player.m_debugMode, out var message);
				ShowOperationMessage(message);
				return;
			}
			ZRpc serverRPC = ZNet.instance.GetServerRPC();
			if (serverRPC == null)
			{
				ShowOperationMessage(new PortalRulesMessage("$sighsorry_portalrules_server_connection_unavailable"));
				return;
			}
			serverRPC.Invoke("sighsorry.PortalRules.ChangeAdminPortalRequiredGlobalKey.v1", new object[3]
			{
				portalId,
				requiredGlobalKey ?? "",
				Player.m_debugMode
			});
		}

		private static void OnRemoteTagChange(ZRpc rpc, ZDOID portalId, string tag, bool debugEnabled)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if (!TryResolveRemoteAdminOperation(rpc, out ZNetPeer peer, out bool requesterIsAdmin, out PortalRulesMessage rejection))
			{
				if (peer != null)
				{
					PublicPortalServerPolicy.SendPolicyMessage(peer, rejection);
				}
			}
			else
			{
				LogRejectedOperation(TryApplyTagChange(portalId, tag, peer, requesterIsAdmin, debugEnabled, out var message), peer, portalId, "tag change", message);
				PublicPortalServerPolicy.SendPolicyMessage(peer, message);
			}
		}

		private static void OnRemoteRemoval(ZRpc rpc, ZDOID portalId, bool debugEnabled)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			if (!TryResolveRemoteAdminOperation(rpc, out ZNetPeer peer, out bool requesterIsAdmin, out PortalRulesMessage rejection))
			{
				if (peer != null)
				{
					PublicPortalServerPolicy.SendPolicyMessage(peer, rejection);
				}
			}
			else
			{
				LogRejectedOperation(TryApplyRemoval(portalId, peer, requesterIsAdmin, debugEnabled, out var message), peer, portalId, "removal", message);
				PublicPortalServerPolicy.SendPolicyMessage(peer, message);
			}
		}

		private static void OnRemoteRequiredGlobalKeyChange(ZRpc rpc, ZDOID portalId, string requiredGlobalKey, bool debugEnabled)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if (!TryResolveRemoteAdminOperation(rpc, out ZNetPeer peer, out bool requesterIsAdmin, out PortalRulesMessage rejection))
			{
				if (peer != null)
				{
					PublicPortalServerPolicy.SendPolicyMessage(peer, rejection);
				}
			}
			else
			{
				LogRejectedOperation(TryApplyRequiredGlobalKeyChange(portalId, requiredGlobalKey, peer, requesterIsAdmin, debugEnabled, out var message), peer, portalId, "Required GlobalKey change", message);
				PublicPortalServerPolicy.SendPolicyMessage(peer, message);
			}
		}

		private static bool TryResolveRemoteAdminOperation(ZRpc rpc, out ZNetPeer? peer, out bool requesterIsAdmin, out PortalRulesMessage rejection)
		{
			peer = null;
			requesterIsAdmin = false;
			rejection = new PortalRulesMessage("$sighsorry_portalrules_admin_request_unauthenticated");
			ZNet instance = ZNet.instance;
			if ((Object)(object)instance == (Object)null || !instance.IsServer())
			{
				return false;
			}
			peer = PublicPortalData.FindPeer(instance, rpc);
			if (peer == null || !peer.IsReady())
			{
				return false;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (LastAdminOperationAt.TryGetValue(rpc, out var value) && realtimeSinceStartup - value < 0.25f)
			{
				rejection = new PortalRulesMessage("$sighsorry_portalrules_admin_change_rate_limited");
				return false;
			}
			LastAdminOperationAt[rpc] = realtimeSinceStartup;
			requesterIsAdmin = PublicPortalData.IsPeerAdmin(instance, peer);
			return true;
		}

		private static bool TryApplyTagChange(ZDOID portalId, string tag, ZNetPeer? requesterPeer, bool requesterIsAdmin, bool debugEnabled, out PortalRulesMessage message)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			if (!TryGetAuthorizedAdminPortal(portalId, requesterPeer, requesterIsAdmin, debugEnabled, out ZDO zdo, out message))
			{
				return false;
			}
			if (tag == null)
			{
				tag = "";
			}
			if (tag.Length > 10)
			{
				message = new PortalRulesMessage("$sighsorry_portalrules_admin_tag_length_limit", 10.ToString(CultureInfo.InvariantCulture));
				return false;
			}
			if (!PublicPortalCatalog.SetAuthoritativeAdminPortalTag(zdo, tag))
			{
				message = new PortalRulesMessage("$sighsorry_portalrules_admin_tag_update_failed");
				return false;
			}
			message = new PortalRulesMessage("$sighsorry_portalrules_admin_tag_updated");
			return true;
		}

		private static bool TryApplyRemoval(ZDOID portalId, ZNetPeer? requesterPeer, bool requesterIsAdmin, bool debugEnabled, out PortalRulesMessage message)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			if (!TryGetAuthorizedAdminPortal(portalId, requesterPeer, requesterIsAdmin, debugEnabled, out ZDO zdo, out message))
			{
				return false;
			}
			if (!PublicPortalServerPolicy.QueueAdminPortalRemoval(zdo))
			{
				message = new PortalRulesMessage("$sighsorry_portalrules_admin_portal_removal_unavailable");
				return false;
			}
			message = new PortalRulesMessage("$sighsorry_portalrules_admin_portal_dismantling_queued");
			return true;
		}

		private static bool TryApplyRequiredGlobalKeyChange(ZDOID portalId, string requiredGlobalKey, ZNetPeer? requesterPeer, bool requesterIsAdmin, bool debugEnabled, out PortalRulesMessage message)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			if (!TryGetAuthorizedAdminPortal(portalId, requesterPeer, requesterIsAdmin, debugEnabled, out ZDO zdo, out message))
			{
				return false;
			}
			if (!TryNormalizeRequiredGlobalKeyMessage(requiredGlobalKey, out string normalizedRequiredGlobalKey, out message))
			{
				return false;
			}
			if (normalizedRequiredGlobalKey.Length != 0 && RequiredGlobalKeyAccess.YouAreNotWorthyInstalled)
			{
				switch ((requesterPeer != null) ? RequiredGlobalKeyAccess.QueryPeer(requesterPeer, normalizedRequiredGlobalKey) : RequiredGlobalKeyAccess.QueryLocal(normalizedRequiredGlobalKey))
				{
				case RequiredGlobalKeyQueryResult.Invalid:
					message = new PortalRulesMessage("$sighsorry_portalrules_ynw_required_global_key_rejected");
					return false;
				case RequiredGlobalKeyQueryResult.Unavailable:
					message = new PortalRulesMessage("$sighsorry_portalrules_ynw_key_api_unavailable");
					return false;
				}
			}
			if (!PublicPortalCatalog.SetAuthoritativeAdminPortalRequiredGlobalKey(zdo, normalizedRequiredGlobalKey))
			{
				message = new PortalRulesMessage("$sighsorry_portalrules_admin_required_global_key_update_failed");
				return false;
			}
			message = ((normalizedRequiredGlobalKey.Length == 0) ? new PortalRulesMessage("$sighsorry_portalrules_admin_required_global_key_cleared") : new PortalRulesMessage("$sighsorry_portalrules_admin_required_global_key_updated"));
			return true;
		}

		private static bool TryNormalizeRequiredGlobalKeyMessage(string? requiredGlobalKey, out string normalizedRequiredGlobalKey, out PortalRulesMessage message)
		{
			if (PublicPortalData.TryNormalizeRequiredGlobalKey(requiredGlobalKey, out normalizedRequiredGlobalKey, out var failure))
			{
				message = PortalRulesMessage.Empty;
				return true;
			}
			switch (failure)
			{
			case RequiredGlobalKeyValidationFailure.TooLong:
				message = new PortalRulesMessage("$sighsorry_portalrules_required_global_key_length_limit", 128.ToString(CultureInfo.InvariantCulture));
				break;
			case RequiredGlobalKeyValidationFailure.ControlCharacters:
				message = new PortalRulesMessage("$sighsorry_portalrules_required_global_key_control_characters");
				break;
			case RequiredGlobalKeyValidationFailure.NumericKey:
				message = new PortalRulesMessage("$sighsorry_portalrules_required_global_key_numeric_invalid");
				break;
			case RequiredGlobalKeyValidationFailure.ReservedKey:
				message = new PortalRulesMessage("$sighsorry_portalrules_required_global_key_not_allowed");
				break;
			default:
				message = new PortalRulesMessage("$sighsorry_portalrules_admin_required_global_key_update_failed");
				break;
			}
			return false;
		}

		private static bool TryGetAuthorizedAdminPortal(ZDOID portalId, ZNetPeer? requesterPeer, bool requesterIsAdmin, bool debugEnabled, out ZDO zdo, out PortalRulesMessage message)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			zdo = null;
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || ZDOMan.instance == null)
			{
				message = new PortalRulesMessage("$sighsorry_portalrules_server_not_ready");
				return false;
			}
			if (!requesterIsAdmin || !debugEnabled)
			{
				message = new PortalRulesMessage("$sighsorry_portalrules_admin_portal_controls_require_admin_debug");
				return false;
			}
			ZDO zDO = ZDOMan.instance.GetZDO(portalId);
			if (zDO == null || !zDO.IsValid() || !PublicPortalInteraction.IsAdminPortal(zDO))
			{
				message = new PortalRulesMessage("$sighsorry_portalrules_requested_admin_portal_unavailable");
				return false;
			}
			if (!PublicPortalInteraction.TryValidatePortalInteraction(zDO, requesterPeer, out message))
			{
				return false;
			}
			if (!((requesterPeer != null) ? PublicPortalData.TryGetPeerOwner(requesterPeer, out var _) : PublicPortalData.LocalOwner().IsValid))
			{
				message = new PortalRulesMessage("$sighsorry_portalrules_platform_identity_unverified");
				return false;
			}
			zdo = zDO;
			return true;
		}

		private static void LogRejectedOperation(bool success, ZNetPeer peer, ZDOID portalId, string operation, PortalRulesMessage message)
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			if (!success && PublicPortalData.TryGetPeerOwner(peer, out var owner))
			{
				string text = (message.IsEmpty ? "<empty>" : ((message.Arguments.Length == 0) ? message.Token : (message.Token + " [" + string.Join(", ", message.Arguments) + "]")));
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)$"Rejected admin portal {operation} from {owner.Id} for {portalId}: {text}");
			}
		}

		private static void ShowOperationMessage(PortalRulesMessage message)
		{
			string text = message.Localize();
			if (!string.IsNullOrWhiteSpace(text))
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)2, text, 0, (Sprite)null);
				}
			}
		}
	}
	internal readonly struct PortalClanMembership
	{
		private readonly string? _primaryClanId;

		private readonly string? _primaryClanName;

		private readonly string? _guestClanId;

		public string PrimaryClanId => _primaryClanId ?? string.Empty;

		public string PrimaryClanName => _primaryClanName ?? string.Empty;

		public string GuestClanId => _guestClanId ?? string.Empty;

		public bool HasPrimaryClan => PrimaryClanId.Length != 0;

		public PortalClanMembership(string primaryClanId, string primaryClanName, string guestClanId)
		{
			_primaryClanId = Normalize(primaryClanId);
			_primaryClanName = ((_primaryClanId.Length == 0) ? string.Empty : Normalize(primaryClanName));
			_guestClanId = Normalize(guestClanId);
		}

		public bool ContainsClan(string clanId)
		{
			string text = Normalize(clanId);
			if (text.Length != 0)
			{
				if (!string.Equals(text, PrimaryClanId, StringComparison.Ordinal))
				{
					return string.Equals(text, GuestClanId, StringComparison.Ordinal);
				}
				return true;
			}
			return false;
		}

		private static string Normalize(string? value)
		{
			return (value ?? string.Empty).Trim();
		}
	}
	internal static class ClanPortalAccess
	{
		private const string ClanApiTypeName = "Clan.ClanApi";

		private const int MinimumApiVersion = 4;

		private const string ResolvedResultName = "Resolved";

		private static readonly object Sync = new object();

		private static MemberInfo? _apiVersionMember;

		private static MethodInfo? _resolveMembershipsMethod;

		private static System.Reflection.EventInfo? _registryChangedEventInfo;

		private static Delegate? _registryChangedHandler;

		private static bool _initialized;

		private static bool _apiAvailable;

		private static bool _registryChangedEventBound;

		private static bool _bindingFailureLogged;

		private static bool _invocationFailureLogged;

		internal static bool IsServerRegistryAvailable
		{
			get
			{
				lock (Sync)
				{
					return IsApiAvailableLocked();
				}
			}
		}

		internal static event Action? RegistryChanged;

		internal static void Initialize()
		{
			lock (Sync)
			{
				if (_initialized)
				{
					return;
				}
				_initialized = true;
				Assembly installedClanAssembly = GetInstalledClanAssembly();
				if (!(installedClanAssembly == null))
				{
					BindAssemblyLocked(installedClanAssembly);
					if (_resolveMembershipsMethod == null || _registryChangedEventInfo == null || !TryReadApiVersion(out var apiVersion) || apiVersion < 4)
					{
						LogBindingFailureOnce($"Clan integration requires API version {4} " + "with ResolveMemberships and RegistryChanged; integration is disabled.");
						ResetBindingLocked();
					}
					else if (!TryBindRegistryChangedEventLocked())
					{
						LogBindingFailureOnce("Could not bind Clan.RegistryChanged; Clan integration is disabled.");
						ResetBindingLocked();
					}
					else
					{
						_apiAvailable = true;
					}
				}
			}
		}

		internal static void Shutdown()
		{
			lock (Sync)
			{
				_initialized = false;
				ResetBindingLocked();
			}
		}

		internal static bool TryResolvePeerMembership(ZNetPeer? peer, out PortalClanMembership membership)
		{
			membership = default(PortalClanMembership);
			if (TryGetPeerIdentity(peer, out string platformId, out long playerId))
			{
				return TryResolveMembership(platformId, playerId, out membership);
			}
			return false;
		}

		internal static bool TryResolveLocalMembership(out PortalClanMembership membership)
		{
			membership = default(PortalClanMembership);
			if (!TryGetLocalIdentity(out string platformId, out long playerId))
			{
				return false;
			}
			return TryResolveMembership(platformId, playerId, out membership);
		}

		internal static bool TryResolveBuilderMembership(PortalBuilder builder, out PortalClanMembership membership)
		{
			membership = default(PortalClanMembership);
			if (builder.IsValid && builder.CharacterPlayerId != 0L)
			{
				return TryResolveMembership(builder.PlatformId, builder.CharacterPlayerId, out membership);
			}
			return false;
		}

		internal static bool IsRequesterInBuilderPrimaryClan(PortalBuilder builder, ZNetPeer? requesterPeer)
		{
			if (!TryResolveBuilderMembership(builder, out var membership) || !membership.HasPrimaryClan)
			{
				return false;
			}
			if ((requesterPeer != null) ? TryResolvePeerMembership(requesterPeer, out var membership2) : TryResolveLocalMembership(out membership2))
			{
				return membership2.ContainsClan(membership.PrimaryClanId);
			}
			return false;
		}

		private static bool TryResolveMembership(string platformId, long playerId, out PortalClanMembership membership)
		{
			membership = default(PortalClanMembership);
			if (string.IsNullOrWhiteSpace(platformId) || playerId == 0L)
			{
				return false;
			}
			MethodInfo resolveMembershipsMethod;
			lock (Sync)
			{
				if (!IsApiAvailableLocked())
				{
					return false;
				}
				resolveMembershipsMethod = _resolveMembershipsMethod;
			}
			if (resolveMembershipsMethod == null)
			{
				return false;
			}
			object[] array = new object[6]
			{
				platformId.Trim(),
				playerId,
				null,
				null,
				null,
				null
			};
			try
			{
				if (!string.Equals(resolveMembershipsMethod.Invoke(null, array)?.ToString(), "Resolved", StringComparison.Ordinal))
				{
					return false;
				}
				membership = new PortalClanMembership((array[2] as string) ?? string.Empty, (array[3] as string) ?? string.Empty, (array[4] as string) ?? string.Empty);
				return true;
			}
			catch (Exception exception)
			{
				LogInvocationFailureOnce(exception);
				membership = default(PortalClanMembership);
				return false;
			}
		}

		private static bool TryGetPeerIdentity(ZNetPeer? peer, out string platformId, out long playerId)
		{
			platformId = string.Empty;
			playerId = 0L;
			if (PublicPortalData.TryGetPeerSteamId64(peer, out platformId))
			{
				return PublicPortalData.TryGetAuthenticatedPeerPlayerId(peer, out playerId);
			}
			return false;
		}

		private static bool TryGetLocalIdentity(out string platformId, out long playerId)
		{
			//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)
			platformId = string.Empty;
			playerId = 0L;
			try
			{
				IDistributionPlatform distributionPlatform = PlatformManager.DistributionPlatform;
				Player localPlayer = Player.m_localPlayer;
				if (((distributionPlatform != null) ? distributionPlatform.LocalUser : null) == null || (Object)(object)localPlayer == (Object)null)
				{
					return false;
				}
				platformId = ((object)((IUser)distributionPlatform.LocalUser).PlatformUserID/*cast due to .constrained prefix*/).ToString().Trim();
				playerId = localPlayer.GetPlayerID();
				return platformId.Length != 0 && playerId != 0;
			}
			catch (Exception)
			{
				platformId = string.Empty;
				playerId = 0L;
				return false;
			}
		}

		private static bool IsApiAvailableLocked()
		{
			if (_initialized && _apiAvailable && _resolveMembershipsMethod != null)
			{
				return _registryChangedEventBound;
			}
			return false;
		}

		private static void BindAssemblyLocked(Assembly assembly)
		{
			Type type = assembly.GetType("Clan.ClanApi", throwOnError: false);
			if (!(type == null))
			{
				_apiVersionMember = (MemberInfo?)(((object)type.GetProperty("ApiVersion", BindingFlags.Static | BindingFlags.Public)) ?? ((object)type.GetField("ApiVersion", BindingFlags.Static | BindingFlags.Public)));
				_resolveMembershipsMethod = type.GetMethod("ResolveMemberships", BindingFlags.Static | BindingFlags.Public, null, new Type[6]
				{
					typeof(string),
					typeof(long),
					typeof(string).MakeByRefType(),
					typeof(string).MakeByRefType(),
					typeof(string).MakeByRefType(),
					typeof(string).MakeByRefType()
				}, null);
				_registryChangedEventInfo = type.GetEvent("RegistryChanged", BindingFlags.Static | BindingFlags.Public);
			}
		}

		private static Assembly? GetInstalledClanAssembly()
		{
			try
			{
				PluginInfo value;
				return (!Chainloader.PluginInfos.TryGetValue("sighsorry.Clan", out value)) ? null : ((object)value.Instance)?.GetType().Assembly;
			}
			catch (Exception ex)
			{
				LogBindingFailureOnce("Could not inspect the installed Clan plugin; integration is disabled: " + ex.Message);
				return null;
			}
		}

		private static bool TryReadApiVersion(out int apiVersion)
		{
			apiVersion = 0;
			try
			{
				MemberInfo apiVersionMember = _apiVersionMember;
				object obj = ((apiVersionMember is PropertyInfo propertyInfo) ? propertyInfo.GetValue(null, null) : ((!(apiVersionMember is FieldInfo fieldInfo)) ? null : fieldInfo.GetValue(null)));
				object obj2 = obj;
				if (obj2 == null)
				{
					return false;
				}
				apiVersion = Convert.ToInt32(obj2);
				return true;
			}
			catch (Exception)
			{
				return false;
			}
		}

		private static bool TryBindRegistryChangedEventLocked()
		{
			if (_registryChangedEventInfo?.EventHandlerType != typeof(Action))
			{
				return false;
			}
			try
			{
				_registryChangedHandler = new Action(HandleRegistryChanged);
				_registryChangedEventInfo.AddEventHandler(null, _registryChangedHandler);
				_registryChangedEventBound = true;
				return true;
			}
			catch (Exception)
			{
				_registryChangedHandler = null;
				_registryChangedEventBound = false;
				return false;
			}
		}

		private static void HandleRegistryChanged()
		{
			Delegate[] invocationList;
			lock (Sync)
			{
				if (!_initialized || ClanPortalAccess.RegistryChanged == null)
				{
					return;
				}
				invocationList = ClanPortalAccess.RegistryChanged.GetInvocationList();
			}
			Delegate[] array = invocationList;
			foreach (Delegate obj in array)
			{
				try
				{
					((Action)obj)();
				}
				catch (Exception)
				{
				}
			}
		}

		private static void ResetBindingLocked()
		{
			if (_registryChangedEventBound && _registryChangedEventInfo != null && (object)_registryChangedHandler != null)
			{
				try
				{
					_registryChangedEventInfo.RemoveEventHandler(null, _registryChangedHandler);
				}
				catch (Exception)
				{
				}
			}
			_apiAvailable = false;
			_registryChangedEventBound = false;
			_registryChangedHandler = null;
			_registryChangedEventInfo = null;
			_resolveMembershipsMethod = null;
			_apiVersionMember = null;
		}

		private static void LogBindingFailureOnce(string message)
		{
			if (!_bindingFailureLogged)
			{
				_bindingFailureLogged = true;
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)message);
			}
		}

		private static void LogInvocationFailureOnce(Exception exception)
		{
			lock (Sync)
			{
				if (_invocationFailureLogged)
				{
					return;
				}
				_invocationFailureLogged = true;
			}
			PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("Clan.ResolveMemberships failed; the request was denied: " + exception.Message));
		}
	}
	internal enum InviteTravelCooldownFailure : byte
	{
		None,
		DataUnavailable,
		StorageUnavailable,
		Active,
		AccountCapacityReached,
		PortalCapacityReached,
		FileCapacityReached,
		SaveFailed,
		ReservationConflict
	}
	internal readonly struct InviteTravelCooldownReservation
	{
		internal readonly string ReservationId;

		internal readonly string AccountId;

		internal readonly string SourceFavoriteId;

		internal readonly string DestinationFavoriteId;

		internal readonly bool RecordsDeparture;

		internal readonly bool RecordsArrival;

		internal bool IsActive
		{
			get
			{
				if (!RecordsDeparture)
				{
					return RecordsArrival;
				}
				return true;
			}
		}

		internal InviteTravelCooldownReservation(string reservationId, string accountId, string sourceFavoriteId, string destinationFavoriteId, bool recordsDeparture, bool recordsArrival)
		{
			ReservationId = reservationId;
			AccountId = accountId;
			SourceFavoriteId = sourceFavoriteId;
			DestinationFavoriteId = destinationFavoriteId;
			RecordsDeparture = recordsDeparture;
			RecordsArrival = recordsArrival;
		}
	}
	internal static class InviteTravelCooldownStore
	{
		private sealed class PendingReservation
		{
			internal readonly InviteTravelCooldownReservation Value;

			internal readonly long ExpiresAtUtc;

			internal readonly long SerializedByteEstimate;

			internal PendingReservation(InviteTravelCooldownReservation value, long expiresAtUtc, long serializedByteEstimate)
			{
				Value = value;
				ExpiresAtUtc = expiresAtUtc;
				SerializedByteEstimate = serializedByteEstimate;
			}
		}

		private sealed class CooldownFile
		{
			[YamlMember(Alias = "format_version")]
			public int FormatVersion { get; set; }

			[YamlMember(Alias = "worlds")]
			public Dictionary<string, Dictionary<string, Dictionary<string, CooldownEntryYaml>>>? Worlds { get; set; }
		}

		private sealed class CooldownEntryYaml
		{
			[YamlMember(Alias = "departure_last_utc")]
			public long DepartureLastUtc { get; set; }

			[YamlMember(Alias = "arrival_last_utc")]
			public long ArrivalLastUtc { get; set; }
		}

		private readonly struct CooldownEntry
		{
			public readonly long DepartureLastUtc;

			public readonly long ArrivalLastUtc;

			public CooldownEntry(long departureLastUtc, long arrivalLastUtc)
			{
				DepartureLastUtc = Math.Max(0L, departureLastUtc);
				ArrivalLastUtc = Math.Max(0L, arrivalLastUtc);
			}

			public CooldownEntry WithDeparture(long value)
			{
				return new CooldownEntry(value, ArrivalLastUtc);
			}

			public CooldownEntry WithArrival(long value)
			{
				return new CooldownEntry(DepartureLastUtc, value);
			}
		}

		private const int FormatVersion = 1;

		private const int MaximumWorldCount = 1024;

		private const int MaximumAccountsPerWorld = 32768;

		private const int MaximumPortalsPerAccount = 100000;

		private const long MaximumFileBytes = 16777216L;

		private const int MaximumSerializedPortalMutationBytes = 256;

		private const int MaximumSerializedAccountHeaderBytes = 64;

		private const int MaximumPendingReservations = 4096;

		private const int MaximumReservationIdLength = 128;

		private const long PendingReservationLifetimeSeconds = 180L;

		private const long MaximumUtcSeconds = 253402300799L;

		private const string DirectoryName = "PortalRules";

		private const string FileName = "invite-travel-cooldowns.yml";

		private static readonly TimeSpan SaveDebounce = TimeSpan.FromSeconds(1.0);

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

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

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

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

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

		private static string _filePath = "";

		private static string _worldId = "";

		private static bool _serverActive;

		private static bool _saveDirty;

		private static bool _saveFaulted;

		private static DateTime _nextSaveAttemptUtc;

		private static long _serializedByteUpperBound;

		internal static void BeginServerSession()
		{
			ClearPendingReservations();
			if (!EndServerSession())
			{
				PortalRulesPlugin.PortalRulesLogger.LogError((object)"Invite cooldown storage retained unsaved data from the previous session; the new session will remain unavailable until that data can be saved.");
			}
			else
			{
				if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || ZNet.World == null)
				{
					return;
				}
				long uid = ZNet.World.m_uid;
				if (uid != 0L)
				{
					_worldId = uid.ToString(CultureInfo.InvariantCulture);
					string text = Path.Combine(Paths.ConfigPath, "PortalRules");
					_filePath = Path.Combine(text, "invite-travel-cooldowns.yml");
					try
					{
						Directory.CreateDirectory(text);
						Load();
						bool flag = Prune(UtcNowSeconds());
						if (!Worlds.ContainsKey(_worldId))
						{
							if (Worlds.Count >= 1024)
							{
								throw new InvalidDataException(string.Format("{0} cannot track more than {1} worlds", "invite-travel-cooldowns.yml", 1024));
							}
							Worlds.Add(_worldId, new Dictionary<string, Dictionary<string, CooldownEntry>>(StringComparer.Ordinal));
							flag = true;
						}
						if (flag)
						{
							Save();
						}
						_saveDirty = false;
						_saveFaulted = false;
						_nextSaveAttemptUtc = DateTime.UtcNow + SaveDebounce;
						_serverActive = true;
						return;
					}
					catch (Exception ex)
					{
						Worlds.Clear();
						_worldId = "";
						_filePath = "";
						_serverActive = false;
						_saveDirty = false;
						_saveFaulted = false;
						_nextSaveAttemptUtc = DateTime.MinValue;
						_serializedByteUpperBound = 0L;
						PortalRulesPlugin.PortalRulesLogger.LogError((object)("Failed to initialize Invite cooldown storage: " + ex.Message));
						return;
					}
				}
				PortalRulesPlugin.PortalRulesLogger.LogError((object)"Invite cooldown storage is unavailable because the world UID is invalid.");
			}
		}

		internal static bool EndServerSession()
		{
			ClearPendingReservations();
			bool num = Flush();
			_serverActive = false;
			if (!num && _saveDirty)
			{
				PortalRulesPlugin.PortalRulesLogger.LogError((object)"Invite cooldown storage could not complete its final save; unsaved data is being retained in memory.");
				return false;
			}
			_saveDirty = false;
			_saveFaulted = false;
			_nextSaveAttemptUtc = DateTime.MinValue;
			_serializedByteUpperBound = 0L;
			_worldId = "";
			_filePath = "";
			Worlds.Clear();
			return true;
		}

		internal static void Tick()
		{
			PrunePendingReservations(UtcNowSeconds());
			if (_saveDirty && !(DateTime.UtcNow < _nextSaveAttemptUtc))
			{
				bool flag = !_serverActive && !string.IsNullOrEmpty(_filePath);
				if (TryFlushPending(out string _) && flag && !((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer() && ZNet.World != null)
				{
					BeginServerSession();
				}
			}
		}

		internal static bool Flush()
		{
			if (!_saveDirty)
			{
				return true;
			}
			if (string.IsNullOrEmpty(_filePath))
			{
				return false;
			}
			string error;
			return TryFlushPending(out error);
		}

		internal static void GetServerDeadlines(string steamId, string favoriteId, out long departureUntilUtc, out long arrivalUntilUtc)
		{
			departureUntilUtc = 0L;
			arrivalUntilUtc = 0L;
			if (_serverActive && TryNormalizeKeys(steamId, favoriteId, out string accountId, out string portalId) && TryGetEntry(accountId, portalId, out var entry))
			{
				departureUntilUtc = CalculateDeadline(entry.DepartureLastUtc, PublicPortalConfig.InviteDepartureCooldownHours.Value);
				arrivalUntilUtc = CalculateDeadline(entry.ArrivalLastUtc, PublicPortalConfig.InviteArrivalCooldownHours.Value);
			}
		}

		internal static void RemovePortal(string favoriteId)
		{
			if (!_serverActive || !PublicPortalData.TryNormalizeFavoriteId(favoriteId, out string portalId) || !TryGetCurrentWorldAccounts(out Dictionary<string, Dictionary<string, CooldownEntry>> accounts))
			{
				return;
			}
			PendingReservation[] array = PendingReservations.Values.Where((PendingReservation candidate) => (candidate.Value.RecordsDeparture && string.Equals(candidate.Value.SourceFavoriteId, portalId, StringComparison.Ordinal)) || (candidate.Value.RecordsArrival && string.Equals(candidate.Value.DestinationFavoriteId, portalId, StringComparison.Ordinal))).ToArray();
			for (int num = 0; num < array.Length; num++)
			{
				RemovePendingReservation(array[num]);
			}
			bool flag = false;
			foreach (Dictionary<string, CooldownEntry> value in accounts.Values)
			{
				flag |= value.Remove(portalId);
			}
			if (flag)
			{
				string[] array2 = (from pair in accounts
					where pair.Value.Count == 0
					select pair.Key).ToArray();
				foreach (string key in array2)
				{
					accounts.Remove(key);
				}
				_saveDirty = true;
			}
		}

		internal static bool TryReserve(string reservationId, string steamId, bool usesInviteAsSource, string sourceFavoriteId, bool usesInviteAsDestination, string destinationFavoriteId, out InviteTravelCooldownReservation reservation, out InviteTravelCooldownFailure failure, out long departureRemaining, out long arrivalRemaining)
		{
			reservation = default(InviteTravelCooldownReservation);
			failure = InviteTravelCooldownFailure.None;
			departureRemaining = 0L;
			arrivalRemaining = 0L;
			double num = PublicPortalConfig.InviteDepartureCooldownHours.Value;
			double num2 = PublicPortalConfig.InviteArrivalCooldownHours.Value;
			bool flag = usesInviteAsSource && num > 0.0;
			bool flag2 = usesInviteAsDestination && num2 > 0.0;
			if (!flag && !flag2)
			{
				return true;
			}
			string normalizedFavoriteId = "";
			string normalizedFavoriteId2 = "";
			if (string.IsNullOrWhiteSpace(reservationId) || reservationId.Length > 128 || !_serverActive || !PublicPortalData.TryNormalizeSteamId64(steamId, out string steamId2) || (flag && !PublicPortalData.TryNormalizeFavoriteId(sourceFavoriteId, out normalizedFavoriteId)) || (flag2 && !PublicPortalData.TryNormalizeFavoriteId(destinationFavoriteId, out normalizedFavoriteId2)))
			{
				failure = InviteTravelCooldownFailure.DataUnavailable;
				return false;
			}
			if (_saveFaulted && (DateTime.UtcNow < _nextSaveAttemptUtc || !TryFlushPending(out string error)))
			{
				failure = InviteTravelCooldownFailure.StorageUnavailable;
				return false;
			}
			long num3 = UtcNowSeconds();
			PrunePendingReservations(num3);
			if (Prune(num3))
			{
				_saveDirty = true;
				if (!TryFlushPending(out error))
				{
					failure = InviteTravelCooldownFailure.StorageUnavailable;
					return false;
				}
			}
			CooldownEntry entry = default(CooldownEntry);
			CooldownEntry entry2 = default(CooldownEntry);
			if (flag)
			{
				TryGetEntry(steamId2, normalizedFavoriteId, out entry);
			}
			if (flag2)
			{
				TryGetEntry(steamId2, normalizedFavoriteId2, out entry2);
			}
			departureRemaining = (flag ? GetRemainingSeconds(CalculateDeadline(entry.DepartureLastUtc, num), num3) : 0);
			arrivalRemaining = (flag2 ? GetRemainingSeconds(CalculateDeadline(entry2.ArrivalLastUtc, num2), num3) : 0);
			if (departureRemaining > 0 || arrivalRemaining > 0)
			{
				failure = InviteTravelCooldownFailure.Active;
				return false;
			}
			if (PendingReservations.Count >= 4096)
			{
				failure = InviteTravelCooldownFailure.StorageUnavailable;
				return false;
			}
			string text = (flag ? CreateDirectionKey(steamId2, normalizedFavoriteId, departure: true) : "");
			string text2 = (flag2 ? CreateDirectionKey(steamId2, normalizedFavoriteId2, departure: false) : "");
			if ((text.Length > 0 && PendingDirectionOwners.ContainsKey(text)) || (text2.Length > 0 && PendingDirectionOwners.ContainsKey(text2)))
			{
				failure = InviteTravelCooldownFailure.ReservationConflict;
				return false;
			}
			if (!TryGetCurrentWorldAccounts(out Dictionary<string, Dictionary<string, CooldownEntry>> accounts))
			{
				failure = InviteTravelCooldownFailure.DataUnavailable;
				return false;
			}
			Dictionary<string, CooldownEntry> portalEntries;
			bool flag3 = accounts.TryGetValue(steamId2, out portalEntries);
			if (!flag3)
			{
				HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
				foreach (PendingReservation value2 in PendingReservations.Values)
				{
					if (!accounts.ContainsKey(value2.Value.AccountId))
					{
						hashSet.Add(value2.Value.AccountId);
					}
				}
				if (!hashSet.Contains(steamId2) && accounts.Count > 32768 - hashSet.Count - 1)
				{
					failure = InviteTravelCooldownFailure.AccountCapacityReached;
					return false;
				}
				portalEntries = new Dictionary<string, CooldownEntry>(StringComparer.Ordinal);
			}
			HashSet<string> hashSet2 = new HashSet<string>(StringComparer.Ordinal);
			foreach (PendingReservation value3 in PendingReservations.Values)
			{
				InviteTravelCooldownReservation value = value3.Value;
				if (string.Equals(value.AccountId, steamId2, StringComparison.Ordinal))
				{
					if (value.RecordsDeparture)
					{
						hashSet2.Add(value.SourceFavoriteId);
					}
					if (value.RecordsArrival)
					{
						hashSet2.Add(value.DestinationFavoriteId);
					}
				}
			}
			HashSet<string> hashSet3 = new HashSet<string>(StringComparer.Ordinal);
			HashSet<string> hashSet4 = new HashSet<string>(StringComparer.Ordinal);
			if (flag && !portalEntries.ContainsKey(normalizedFavoriteId) && !hashSet2.Contains(normalizedFavoriteId))
			{
				hashSet3.Add(normalizedFavoriteId);
			}
			if (flag)
			{
				hashSet4.Add(normalizedFavoriteId);
			}
			if (flag2 && !portalEntries.ContainsKey(normalizedFavoriteId2) && !hashSet2.Contains(normalizedFavoriteId2))
			{
				hashSet3.Add(normalizedFavoriteId2);
			}
			if (flag2)
			{
				hashSet4.Add(normalizedFavoriteId2);
			}
			int num4 = hashSet2.Count((string favoriteId) => !portalEntries.ContainsKey(favoriteId));
			if (portalEntries.Count > 100000 - num4 - hashSet3.Count)
			{
				failure = InviteTravelCooldownFailure.PortalCapacityReached;
				return false;
			}
			long num5 = (long)hashSet4.Count * 256L + (flag3 ? 0 : 64);
			long num6 = PendingReservations.Values.Sum((PendingReservation pending) => pending.SerializedByteEstimate);
			if (_serializedByteUpperBound > 16777216 - num6 - num5)
			{
				if (!_saveDirty || !TryFlushPending(out error))
				{
					failure = InviteTravelCooldownFailure.FileCapacityReached;
					return false;
				}
				if (_serializedByteUpperBound > 16777216 - num6 - num5)
				{
					failure = InviteTravelCooldownFailure.FileCapacityReached;
					return false;
				}
			}
			reservation = new InviteTravelCooldownReservation(reservationId, steamId2, normalizedFavoriteId, normalizedFavoriteId2, flag, flag2);
			PendingReservations.Add(reservationId, new PendingReservation(reservation, Math.Min(253402300799L, num3 + 180), num5));
			if (text.Length > 0)
			{
				PendingDirectionOwners.Add(text, reservationId);
			}
			if (text2.Length > 0)
			{
				PendingDirectionOwners.Add(text2, reservationId);
			}
			return true;
		}

		internal static bool TryCommitReservation(InviteTravelCooldownReservation reservation, out InviteTravelCooldownFailure failure)
		{
			failure = InviteTravelCooldownFailure.None;
			if (!reservation.IsActive)
			{
				return true;
			}
			long num = UtcNowSeconds();
			if (!PendingReservations.TryGetValue(reservation.ReservationId, out PendingReservation value) || value.ExpiresAtUtc < num || !ReservationMatches(reservation, value.Value))
			{
				CancelReservation(reservation.ReservationId);
				failure = InviteTravelCooldownFailure.DataUnavailable;
				return false;
			}
			if (!_serverActive)
			{
				failure = InviteTravelCooldownFailure.DataUnavailable;
				return false;
			}
			if (_saveFaulted && (DateTime.UtcNow < _nextSaveAttemptUtc || !TryFlushPending(out string error)))
			{
				failure = InviteTravelCooldownFailure.StorageUnavailable;
				return false;
			}
			if (!TryGetCurrentWorldAccounts(out Dictionary<string, Dictionary<string, CooldownEntry>> accounts))
			{
				failure = InviteTravelCooldownFailure.DataUnavailable;
				return false;
			}
			Dictionary<string, CooldownEntry> value2;
			bool flag = accounts.TryGetValue(reservation.AccountId, out value2);
			if (!flag)
			{
				if (accounts.Count >= 32768)
				{
					failure = InviteTravelCooldownFailure.AccountCapacityReached;
					return false;
				}
				value2 = new Dictionary<string, CooldownEntry>(StringComparer.Ordinal);
			}
			CooldownEntry value3 = default(CooldownEntry);
			CooldownEntry value4 = default(CooldownEntry);
			bool flag2 = reservation.RecordsDeparture && value2.TryGetValue(reservation.SourceFavoriteId, out value3);
			bool flag3 = reservation.RecordsArrival && value2.TryGetValue(reservation.DestinationFavoriteId, out value4);
			int num2 = 0;
			if (reservation.RecordsDeparture && !flag2)
			{
				num2++;
			}
			if (reservation.RecordsArrival && !flag3 && (!reservation.RecordsDeparture || !string.Equals(reservation.SourceFavoriteId, reservation.DestinationFavoriteId, StringComparison.Ordinal)))
			{
				num2++;
			}
			if (value2.Count > 100000 - num2)
			{
				failure = InviteTravelCooldownFailure.PortalCapacityReached;
				return false;
			}
			if (_serializedByteUpperBound > 16777216 - value.SerializedByteEstimate)
			{
				failure = InviteTravelCooldownFailure.FileCapacityReached;
				return false;
			}
			if (!flag)
			{
				accounts.Add(reservation.AccountId, value2);
			}
			bool saveDirty = _saveDirty;
			long serializedByteUpperBound = _serializedByteUpperBound;
			if (reservation.RecordsDeparture)
			{
				value2[reservation.SourceFavoriteId] = value3.WithDeparture(num);
			}
			if (reservation.RecordsArrival)
			{
				CooldownEntry value5;
				CooldownEntry cooldownEntry = ((reservation.RecordsDeparture && string.Equals(reservation.SourceFavoriteId, reservation.DestinationFavoriteId, StringComparison.Ordinal) && value2.TryGetValue(reservation.DestinationFavoriteId, out value5)) ? value5 : value4);
				value2[reservation.DestinationFavoriteId] = cooldownEntry.WithArrival(num);
			}
			_serializedByteUpperBound += value.SerializedByteEstimate;
			_saveDirty = true;
			if (TryFlushPending(out error))
			{
				RemovePendingReservation(value);
				return true;
			}
			RestoreEntry(value2, reservation.SourceFavoriteId, flag2, value3);
			RestoreEntry(value2, reservation.DestinationFavoriteId, flag3, value4);
			if (value2.Count == 0)
			{
				accounts.Remove(reservation.AccountId);
			}
			_saveDirty = saveDirty || _saveFaulted;
			_serializedByteUpperBound = serializedByteUpperBound;
			failure = InviteTravelCooldownFailure.SaveFailed;
			return false;
		}

		internal static void CancelReservation(string reservationId)
		{
			if (!string.IsNullOrEmpty(reservationId) && PendingReservations.TryGetValue(reservationId, out PendingReservation value))
			{
				RemovePendingReservation(value);
			}
		}

		internal static string FormatRemaining(long seconds)
		{
			seconds = Math.Max(1L, seconds);
			long num = Math.Max(1L, (seconds + 59) / 60);
			if (num < 60)
			{
				return PortalRulesLocalization.Translate("$sighsorry_portalrules_duration_minutes", num.ToString(CultureInfo.InvariantCulture));
			}
			long num2 = num / 60;
			long num3 = num % 60;
			if (num3 != 0L)
			{
				return PortalRulesLocalization.Translate("$sighsorry_portalrules_duration_hours_minutes", num2.ToString(CultureInfo.InvariantCulture), num3.ToString(CultureInfo.InvariantCulture));
			}
			return PortalRulesLocalization.Translate("$sighsorry_portalrules_duration_hours", num2.ToString(CultureInfo.InvariantCulture));
		}

		internal static long GetRemainingSeconds(long deadlineUtc)
		{
			return GetRemainingSeconds(deadlineUtc, PublicPortalCatalog.GetEstimatedServerUtcNowSeconds());
		}

		internal static bool TryGetInviteArrivalCooldownRemaining(PublicPortalCatalogEntry portal, out long remainingSeconds)
		{
			remainingSeconds = 0L;
			if (portal.AccessMode != PublicPortalAccessMode.Invite || portal.InviteArrivalCooldownUntilUtc <= 0)
			{
				return false;
			}
			remainingSeconds = GetRemainingSeconds(portal.InviteArrivalCooldownUntilUtc);
			return remainingSeconds > 0;
		}

		private static bool TryNormalizeKeys(string steamId, string favoriteId, out string accountId, out string portalId)
		{
			accountId = "";
			portalId = "";
			if (PublicPortalData.TryNormalizeSteamId64(steamId, out accountId))
			{
				return PublicPortalData.TryNormalizeFavoriteId(favoriteId, out portalId);
			}
			return false;
		}

		private static string CreateDirectionKey(string accountId, string favoriteId, bool departure)
		{
			return accountId + (departure ? ":D:" : ":A:") + favoriteId;
		}

		private static bool ReservationMatches(InviteTravelCooldownReservation first, InviteTravelCooldownReservation second)
		{
			if (string.Equals(first.ReservationId, second.ReservationId, StringComparison.Ordinal) && string.Equals(first.AccountId, second.AccountId, StringComparison.Ordinal) && string.Equals(first.SourceFavoriteId, second.SourceFavoriteId, StringComparison.Ordinal) && string.Equals(first.DestinationFavoriteId, second.DestinationFavoriteId, StringComparison.Ordinal) && first.RecordsDeparture == second.RecordsDeparture)
			{
				return first.RecordsArrival == second.RecordsArrival;
			}
			return false;
		}

		private static void PrunePendingReservations(long nowUtc)
		{
			PendingReservation[] array = PendingReservations.Values.Where((PendingReservation candidate) => candidate.ExpiresAtUtc < nowUtc).ToArray();
			for (int num = 0; num < array.Length; num++)
			{
				RemovePendingReservation(array[num]);
			}
		}

		private static void RemovePendingReservation(PendingReservation pending)
		{
			InviteTravelCooldownReservation value = pending.Value;
			PendingReservations.Remove(value.ReservationId);
			if (value.RecordsDeparture)
			{
				PendingDirectionOwners.Remove(CreateDirectionKey(value.AccountId, value.SourceFavoriteId, departure: true));
			}
			if (value.RecordsArrival)
			{
				PendingDirectionOwners.Remove(CreateDirectionKey(value.AccountId, value.DestinationFavoriteId, departure: false));
			}
		}

		private static void ClearPendingReservations()
		{
			PendingReservations.Clear();
			PendingDirectionOwners.Clear();
		}

		private static bool TryGetEntry(string accountId, string portalId, out CooldownEntry entry)
		{
			entry = default(CooldownEntry);
			if (TryGetCurrentWorldAccounts(out Dictionary<string, Dictionary<string, CooldownEntry>> accounts) && accounts.TryGetValue(accountId, out var value))
			{
				return value.TryGetValue(portalId, out entry);
			}
			return false;
		}

		private static bool TryGetCurrentWorldAccounts(out Dictionary<string, Dictionary<string, CooldownEntry>> accounts)
		{
			accounts = null;
			if (!string.IsNullOrEmpty(_worldId))
			{
				return Worlds.TryGetValue(_worldId, out accounts);
			}
			return false;
		}

		private static void RestoreEntry(Dictionary<string, CooldownEntry> entries, string portalId, bool existed, CooldownEntry previous)
		{
			if (!string.IsNullOrEmpty(portalId))
			{
				if (existed)
				{
					entries[portalId] = previous;
				}
				else
				{
					entries.Remove(portalId);
				}
			}
		}

		private static long CalculateDeadline(long lastUtc, double hours)
		{
			if (lastUtc <= 0 || hours <= 0.0 || double.IsNaN(hours) || double.IsInfinity(hours))
			{
				return 0L;
			}
			long num = (long)Math.Ceiling(Math.Min(hours, 8760.0) * 3600.0);
			if (lastUtc <= 253402300799L - num)
			{
				return lastUtc + num;
			}
			return 253402300799L;
		}

		private static long GetRemainingSeconds(long deadlineUtc, long nowUtc)
		{
			if (deadlineUtc <= nowUtc)
			{
				return 0L;
			}
			return deadlineUtc - nowUtc;
		}

		private static long UtcNowSeconds()
		{
			return DateTimeOffset.UtcNow.ToUnixTimeSeconds();
		}

		private static long NormalizeUtcSeconds(long value)
		{
			if (value < 0 || value > 253402300799L)
			{
				return 0L;
			}
			return value;
		}

		private static void Load()
		{
			Worlds.Clear();
			string path = _filePath + ".bak";
			if (!File.Exists(_filePath))
			{
				if (File.Exists(path))
				{
					LoadFromPath(path);
					Save();
					PortalRulesPlugin.PortalRulesLogger.LogWarning((object)"Recovered invite-travel-cooldowns.yml from its backup because the primary file was missing.");
				}
				return;
			}
			try
			{
				LoadFromPath(_filePath);
			}
			catch (Exception ex)
			{
				Worlds.Clear();
				if (!File.Exists(path))
				{
					throw;
				}
				try
				{
					LoadFromPath(path);
					string text = _filePath + ".invalid-" + DateTime.UtcNow.ToString("yyyyMMddHHmmssfff", CultureInfo.InvariantCulture) + "-" + Guid.NewGuid().ToString("N");
					File.Move(_filePath, text);
					Save();
					PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("Recovered invite-travel-cooldowns.yml from its backup. The invalid primary file was preserved as '" + Path.GetFileName(text) + "'."));
				}
				catch (Exception ex2)
				{
					Worlds.Clear();
					throw new InvalidDataException("Failed to load invite-travel-cooldowns.yml and its backup. Primary error: " + ex.Message + ". Recovery error: " + ex2.Message, ex2);
				}
			}
		}

		private static void LoadFromPath(string path)
		{
			Worlds.Clear();
			_serializedByteUpperBound = 0L;
			if (new FileInfo(path).Length > 16777216)
			{
				throw new InvalidDataException($"'{Path.GetFileName(path)}' exceeds {16777216L} bytes");
			}
			string text = File.ReadAllText(path);
			CooldownFile cooldownFile = Deserializer.Deserialize<CooldownFile>(text);
			if (cooldownFile == null || cooldownFile.FormatVersion != 1 || cooldownFile.Worlds == null)
			{
				throw new InvalidDataException(string.Format("{0} must contain format_version {1} and worlds", "invite-travel-cooldowns.yml", 1));
			}
			if (cooldownFile.Worlds.Count > 1024)
			{
				throw new InvalidDataException(string.Format("{0} contains more than {1} worlds", "invite-travel-cooldowns.yml", 1024));
			}
			foreach (KeyValuePair<string, Dictionary<string, Dictionary<string, CooldownEntryYaml>>> world in cooldownFile.Worlds)
			{
				if (!long.TryParse(world.Key, NumberStyles.AllowLeadingSign, CultureInfo.InvariantCulture, out var result) || result == 0L || !string.Equals(world.Key, result.ToString(CultureInfo.InvariantCulture), StringComparison.Ordinal) || world.Value == null || world.Value.Count > 32768)
				{
					throw new InvalidDataException("invite-travel-cooldowns.yml contains an invalid world entry '" + world.Key + "'");
				}
				Dictionary<string, Dictionary<string, CooldownEntry>> dictionary = new Dictionary<string, Dictionary<string, CooldownEntry>>(StringComparer.Ordinal);
				foreach (KeyValuePair<string, Dictionary<string, CooldownEntryYaml>> item in world.Value)
				{
					if (!PublicPortalData.TryNormalizeSteamId64(item.Key, out string steamId) || !string.Equals(item.Key, steamId, StringComparison.Ordinal) || item.Value == null || item.Value.Count > 100000)
					{
						throw new InvalidDataException("invite-travel-cooldowns.yml contains an invalid account entry '" + item.Key + "'");
					}
					Dictionary<string, CooldownEntry> dictionary2 = new Dictionary<string, CooldownEntry>(StringComparer.Ordinal);
					foreach (KeyValuePair<string, CooldownEntryYaml> item2 in item.Value)
					{
						if (!PublicPortalData.TryNormalizeFavoriteId(item2.Key, out string normalizedFavoriteId) || !string.Equals(item2.Key, normalizedFavoriteId, StringComparison.Ordinal) || item2.Value == null || NormalizeUtcSeconds(item2.Value.DepartureLastUtc) != item2.Value.DepartureLastUtc || NormalizeUtcSeconds(item2.Value.ArrivalLastUtc) != item2.Value.ArrivalLastUtc)
						{
							throw new InvalidDataException("invite-travel-cooldowns.yml contains an invalid portal entry '" + item2.Key + "'");
						}
						dictionary2.Add(normalizedFavoriteId, new CooldownEntry(item2.Value.DepartureLastUtc, item2.Value.ArrivalLastUtc));
					}
					dictionary.Add(steamId, dictionary2);
				}
				Worlds.Add(world.Key, dictionary);
			}
			_serializedByteUpperBound = Encoding.UTF8.GetByteCount(text);
		}

		private static bool Prune(long nowUtc)
		{
			bool result = false;
			long oldestUsefulUtc = Math.Max(0L, nowUtc - 31622400);
			string[] array;
			foreach (Dictionary<string, Dictionary<string, CooldownEntry>> value in Worlds.Values)
			{
				foreach (Dictionary<string, CooldownEntry> value2 in value.Values)
				{
					array = (from pair in value2
						where pair.Value.DepartureLastUtc < oldestUsefulUtc && pair.Value.ArrivalLastUtc < oldestUsefulUtc
						select pair.Key).ToArray();
					foreach (string key in array)
					{
						value2.Remove(key);
						result = true;
					}
				}
				array = (from pair in value
					where pair.Value.Count == 0
					select pair.Key).ToArray();
				foreach (string key2 in array)
				{
					value.Remove(key2);
					result = true;
				}
			}
			array = (from pair in Worlds
				where pair.Value.Count == 0 && !string.Equals(pair.Key, _worldId, StringComparison.Ordinal)
				select pair.Key).ToArray();
			foreach (string key3 in array)
			{
				Worlds.Remove(key3);
				result = true;
			}
			return result;
		}

		private static void Save()
		{
			if (string.IsNullOrEmpty(_filePath))
			{
				throw new InvalidOperationException("Invite cooldown path is not initialized");
			}
			if (Worlds.Count > 1024)
			{
				throw new InvalidDataException(string.Format("{0} cannot store more than {1} worlds", "invite-travel-cooldowns.yml", 1024));
			}
			foreach (KeyValuePair<string, Dictionary<string, Dictionary<string, CooldownEntry>>> world in Worlds)
			{
				if (world.Value.Count > 32768)
				{
					throw new InvalidDataException(string.Format("{0} cannot store more than {1} accounts per world", "invite-travel-cooldowns.yml", 32768));
				}
				if (world.Value.Values.Any((Dictionary<string, CooldownEntry> portals) => portals.Count > 100000))
				{
					throw new InvalidDataException(string.Format("{0} cannot store more than {1} portals per account", "invite-travel-cooldowns.yml", 100000));
				}
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("# AUTO-GENERATED by PortalRules. Do not edit while the server is running.");
			stringBuilder.AppendLine("# Cooldowns are scoped by world, SteamID64, portal FavoriteId, and direction.");
			stringBuilder.AppendLine("format_version: 1");
			if (Worlds.Count == 0)
			{
				stringBuilder.AppendLine("worlds: {}");
			}
			else
			{
				stringBuilder.AppendLine("worlds:");
				foreach (KeyValuePair<string, Dictionary<string, Dictionary<string, CooldownEntry>>> item in Worlds.OrderBy<KeyValuePair<string, Dictionary<string, Dictionary<string, CooldownEntry>>>, string>((KeyValuePair<string, Dictionary<string, Dictionary<string, CooldownEntry>>> pair) => pair.Key, StringComparer.Ordinal))
				{
					stringBuilder.Append("  \"").Append(item.Key).AppendLine("\":");
					if (item.Value.Count == 0)
					{
						stringBuilder.AppendLine("    {}");
						continue;
					}
					foreach (KeyValuePair<string, Dictionary<string, CooldownEntry>> item2 in item.Value.OrderBy<KeyValuePair<string, Dictionary<string, CooldownEntry>>, string>((KeyValuePair<string, Dictionary<string, CooldownEntry>> pair) => pair.Key, StringComparer.Ordinal))
					{
						stringBuilder.Append("    \"").Append(item2.Key).AppendLine("\":");
						if (item2.Value.Count == 0)
						{
							stringBuilder.AppendLine("      {}");
							continue;
						}
						foreach (KeyValuePair<string, CooldownEntry> item3 in item2.Value.OrderBy<KeyValuePair<string, CooldownEntry>, string>((KeyValuePair<string, CooldownEntry> pair) => pair.Key, StringComparer.Ordinal))
						{
							stringBuilder.Append("      \"").Append(item3.Key).AppendLine("\":");
							StringBuilder stringBuilder2 = stringBuilder.Append("        departure_last_utc: ");
							long departureLastUtc = item3.Value.DepartureLastUtc;
							stringBuilder2.AppendLine(departureLastUtc.ToString(CultureInfo.InvariantCulture));
							StringBuilder stringBuilder3 = stringBuilder.Append("        arrival_last_utc: ");
							departureLastUtc = item3.Value.ArrivalLastUtc;
							stringBuilder3.AppendLine(departureLastUtc.ToString(CultureInfo.InvariantCulture));
						}
					}
				}
			}
			string text = stringBuilder.ToString();
			int byteCount = Encoding.UTF8.GetByteCount(text);
			if ((long)byteCount > 16777216L)
			{
				throw new InvalidDataException(string.Format("{0} would exceed {1} bytes", "invite-travel-cooldowns.yml", 16777216L));
			}
			PortalAccountStore.WriteAtomicFile(_filePath, text, _filePath + ".bak");
			_serializedByteUpperBound = byteCount;
		}

		private static bool TryFlushPending(out string error)
		{
			error = "";
			if (!_saveDirty)
			{
				_saveFaulted = false;
				return true;
			}
			try
			{
				Save();
				_saveDirty = false;
				_saveFaulted = false;
				_nextSaveAttemptUtc = DateTime.UtcNow + SaveDebounce;
				return true;
			}
			catch (Exception ex)
			{
				_saveDirty = true;
				_saveFaulted = true;
				_nextSaveAttemptUtc = DateTime.UtcNow + SaveRetryDelay;
				error = ex.Message;
				PortalRulesPlugin.PortalRulesLogger.LogError((object)("Failed to save Invite cooldown data: " + ex.Message));
				return false;
			}
		}
	}
	[BepInPlugin("sighsorry.PortalRules", "PortalRules", "1.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInIncompatibility("org.bepinex.plugins.targetportal")]
	public class PortalRulesPlugin : BaseUnityPlugin
	{
		public enum Toggle
		{
			On = 1,
			Off = 0
		}

		private sealed class ConfigurationManagerAttributes
		{
			public int? Order { get; set; }

			public int? CategoryOrder { get; set; }

			public bool? Browsable { get; set; }
		}

		internal const string ModName = "PortalRules";

		internal const string ModVersion = "1.0.0";

		internal const string Author = "sighsorry";

		internal const string ModGUID = "sighsorry.PortalRules";

		internal const string ClanSoftDependencyGuid = "sighsorry.Clan";

		internal const string CurrencyPocketSoftDependencyGuid = "Azumatt.CurrencyPocket";

		internal const string YouAreNotWorthySoftDependencyGuid = "sighsorry.YouAreNotWorthy";

		internal const string TargetPortalIncompatibilityGuid = "org.bepinex.plugins.targetportal";

		private static readonly string ConfigFileName = "sighsorry.PortalRules.cfg";

		private static readonly string ConfigFileFullPath;

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

		public static readonly ManualLogSource PortalRulesLogger;

		private static readonly ConfigSync ConfigSync;

		private FileSystemWatcher? _watcher;

		private readonly object _reloadLock = new object();

		private DateTime _lastConfigReloadTime;

		private int _clanRegistryDirty;

		private const long RELOAD_DELAY = 10000000L;

		private static ConfigEntry<Toggle> _serverConfigLocked;

		internal static bool IsAdmin
		{
			get
			{
				if (!((Object)(object)ZNet.instance == (Object)null) && !ZNet.instance.IsServer())
				{
					return PublicPortalData.ServerAssignedIsAdmin;
				}
				return true;
			}
		}

		internal static bool HasAdminDebugAccess
		{
			get
			{
				if (IsAdmin)
				{
					return Player.m_debugMode;
				}
				return false;
			}
		}

		public void Awake()
		{
			bool saveOnConfigSet = ((BaseUnityPlugin)this).Config.SaveOnConfigSet;
			((BaseUnityPlugin)this).Config.SaveOnConfigSet = false;
			try
			{
				PortalRulesLocalization.Initialize();
				_serverConfigLocked = ConfigEntry("1 - General", "Lock Configuration", Toggle.On, "If on, the configuration is locked and can be changed by server admins only.", synchronizedSetting: true, 200, 500);
				ConfigSync.AddLockingConfigEntry<Toggle>(_serverConfigLocked);
				PublicPortalConfig.Init(this);
				RequiredGlobalKeyAccess.Initialize();
				Assembly executingAssembly = Assembly.GetExecutingAssembly();
				ClanPortalAccess.RegistryChanged += OnClanRegistryChanged;
				ClanPortalAccess.Initialize();
				AdminPortalPrefabManager.Initialize();
				_harmony.PatchAll(executingAssembly);
				((BaseUnityPlugin)this).Config.Save();
			}
			finally
			{
				((BaseUnityPlugin)this).Config.SaveOnConfigSet = saveOnConfigSet;
			}
			SetupWatcher();
		}

		private void Update()
		{
			if (AdminPortalBiomeDefaults.Tick())
			{
				PublicPortalCatalog.RefreshAndBroadcast();
			}
			if (PortalAccountStore.Tick())
			{
				PublicPortalServerPolicy.NotifyQuotaConfigurationChanged();
			}
			InviteTravelCooldownStore.Tick();
			PublicPortalTeleportService.Tick();
			PublicPortalCatalog.TickIdentityRegistry();
			AdminPortalPrefabManager.Tick();
			PublicPortalMapController.Instance.Tick();
			if (Interlocked.Exchange(ref _clanRegistryDirty, 0) != 0)
			{
				PublicPortalCatalog.RefreshClanViews();
			}
		}

		private void OnDestroy()
		{
			try
			{
				TryCleanup("configuration watcher", delegate
				{
					if (_watcher != null)
					{
						_watcher.EnableRaisingEvents = false;
						_watcher.Dispose();
						_watcher = null;
					}
				});
				TryCleanup("portal map", PublicPortalMapController.Instance.End);
				TryCleanup("connected portal HUD", PublicPortalConnectedHud.Shutdown);
				TryCleanup("portal catalog", PublicPortalCatalog.Shutdown);
				TryCleanup("server policy", PublicPortalServerPolicy.Shutdown);
				TryCleanup("teleport service", PublicPortalTeleportService.Shutdown);
				TryCleanup("portal interaction", PublicPortalInteraction.Shutdown);
				TryCleanup("admin portal operations", AdminPortalOperations.Shutdown);
				TryCleanup("admin portal prefabs", AdminPortalPrefabManager.Shutdown);
				TryCleanup("GlobalKey integration", RequiredGlobalKeyAccess.Shutdown);
				TryCleanup("Clan event subscription", delegate
				{
					ClanPortalAccess.RegistryChanged -= OnClanRegistryChanged;
				});
				TryCleanup("Clan integration", ClanPortalAccess.Shutdown);
				TryCleanup("configuration save", delegate
				{
					SaveWithRespectToConfigSet();
				});
			}
			finally
			{
				TryCleanup("Harmony patches", (Action)_harmony.UnpatchSelf);
			}
		}

		private static void TryCleanup(string component, Action cleanup)
		{
			try
			{
				cleanup();
			}
			catch (Exception ex)
			{
				PortalRulesLogger.LogError((object)("Failed to clean up " + component + ": " + ex.Message));
			}
		}

		private void OnClanRegistryChanged()
		{
			Interlocked.Exchange(ref _clanRegistryDirty, 1);
		}

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

		private void ReadConfigValues(object sender, FileSystemEventArgs e)
		{
			DateTime now = DateTime.Now;
			if (now.Ticks - _lastConfigReloadTime.Ticks < 10000000)
			{
				return;
			}
			lock (_reloadLock)
			{
				if (!File.Exists(ConfigFileFullPath))
				{
					PortalRulesLogger.LogWarning((object)"Config file does not exist. Skipping reload.");
					return;
				}
				try
				{
					PortalRulesLogger.LogDebug((object)"Reloading configuration...");
					SaveWithRespectToConfigSet(reload: true);
					PortalRulesLogger.LogInfo((object)"Configuration reload complete.");
				}
				catch (Exception ex)
				{
					PortalRulesLogger.LogError((object)("Error reloading configuration: " + ex.Message));
				}
			}
			_lastConfigReloadTime = now;
		}

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

		internal ConfigEntry<T> ConfigEntry<T>(string group, string name, T value, ConfigDescription description, bool synchronizedSetting = true, int? order = null, int? categoryOrder = null, bool? browsable = null)
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			object[] array = description.Tags ?? Array.Empty<object>();
			if (order.HasValue || categoryOrder.HasValue || browsable.HasValue)
			{
				array = array.Concat(new object[1]
				{
					new ConfigurationManagerAttributes
					{
						Order = order,
						CategoryOrder = categoryOrder,
						Browsable = browsable
					}
				}).ToArray();
			}
			ConfigDescription val = new ConfigDescription(description.Description + (synchronizedSetting ? " [Synced with Server]" : " [Not Synced with Server]"), description.AcceptableValues, array);
			ConfigEntry<T> val2 = ((BaseUnityPlugin)this).Config.Bind<T>(group, name, value, val);
			ConfigSync.AddConfigEntry<T>(val2).SynchronizedConfig = synchronizedSetting;
			return val2;
		}

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

		static PortalRulesPlugin()
		{
			string configPath = Paths.ConfigPath;
			char directorySeparatorChar = Path.DirectorySeparatorChar;
			ConfigFileFullPath = configPath + directorySeparatorChar + ConfigFileName;
			PortalRulesLogger = Logger.CreateLogSource("PortalRules");
			ConfigSync = new ConfigSync("sighsorry.PortalRules")
			{
				DisplayName = "PortalRules",
				CurrentVersion = "1.0.0",
				MinimumRequiredVersion = "1.0.0"
			};
			_serverConfigLocked = null;
		}
	}
	public static class KeyboardExtensions
	{
		public static bool IsKeyDown(this KeyboardShortcut shortcut)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if ((int)((KeyboardShortcut)(ref shortcut)).MainKey != 0 && Input.GetKeyDown(((KeyboardShortcut)(ref shortcut)).MainKey))
			{
				return ((KeyboardShortcut)(ref shortcut)).Modifiers.All((Func<KeyCode, bool>)Input.GetKey);
			}
			return false;
		}

		public static bool IsKeyHeld(this KeyboardShortcut shortcut)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if ((int)((KeyboardShortcut)(ref shortcut)).MainKey != 0 && Input.GetKey(((KeyboardShortcut)(ref shortcut)).MainKey))
			{
				return ((KeyboardShortcut)(ref shortcut)).Modifiers.All((Func<KeyCode, bool>)Input.GetKey);
			}
			return false;
		}
	}
	public static class ToggleExtentions
	{
		public static bool IsOn(this PortalRulesPlugin.Toggle value)
		{
			return value == PortalRulesPlugin.Toggle.On;
		}

		public static bool IsOff(this PortalRulesPlugin.Toggle value)
		{
			return value == PortalRulesPlugin.Toggle.Off;
		}
	}
	internal static class PortalAccountStore
	{
		private sealed class PlayerIdentitiesYaml
		{
			[YamlMember(Alias = "format_version")]
			public int FormatVersion { get; set; }

			[YamlMember(Alias = "identities")]
			public Dictionary<string, string>? Identities { get; set; }
		}

		private sealed class PortalLimitOverridesYaml
		{
			[YamlMember(Alias = "format_version")]
			public int FormatVersion { get; set; }

			[YamlMember(Alias = "overrides")]
			public Dictionary<string, string>? Overrides { get; set; }
		}

		private readonly struct PortalLimitOverride
		{
			public readonly int PortalLimit;

			public readonly int? InviteLimit;

			public PortalLimitOverride(int portalLimit, int? inviteLimit)
			{
				PortalLimit = portalLimit;
				InviteLimit = inviteLimit;
			}

			public bool Matches(PortalLimitOverride other)
			{
				if (PortalLimit == other.PortalLimit)
				{
					return InviteLimit == other.InviteLimit;
				}
				return false;
			}
		}

		private const int IdentityFormatVersion = 1;

		private const int OverrideFormatVersion = 2;

		private const int MaximumIdentityCount = 16384;

		private const int MaximumOverrideCount = 4096;

		private const int MaximumOverrideReloadAttempts = 5;

		private const int MaximumPortalLimit = 10000;

		private const long MaximumIdentityFileBytes = 2097152L;

		private const long MaximumOverrideFileBytes = 524288L;

		private const string DirectoryName = "PortalRules";

		private const string IdentityFileName = "player-identities.yml";

		private const string OverrideFileName = "portal-limit-overrides.yml";

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

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

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

		private static readonly TimeSpan OverrideReloadDebounce = TimeSpan.FromMilliseconds(500.0);

		private static readonly TimeSpan OverrideReloadRetryDelay = TimeSpan.FromSeconds(1.0);

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

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

		private static readonly UTF8Encoding Utf8WithoutBom = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false);

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

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

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

		private static Dictionary<string, PortalLimitOverride> _portalLimitOverrides = new Dictionary<string, PortalLimitOverride>(StringComparer.Ordinal);

		private static FileSystemWatcher? _overrideWatcher;

		private static string _configurationDirectory = "";

		private static string _identityFilePath = "";

		private static string _overrideFilePath = "";

		private static bool _active;

		private static bool _hasValidOverrideSnapshot;

		private static bool _identityDirty;

		private static DateTime _identityFirstDirtyUtc;

		private static DateTime _identitySaveNotBeforeUtc;

		private static DateTime _nextOverridePollUtc;

		private static int _overrideReloadRequested;

		private static int _overrideReloadAttempts;

		private static int _overrideWatcherRestartRequested;

		private static long _overrideReloadNotBeforeUtcTicks;

		private static long _overrideWatcherRestartNotBeforeUtcTicks;

		internal static bool IsActive => _active;

		internal static bool HasValidOverrideSnapshot
		{
			get
			{
				if (_active)
				{
					return _hasValidOverrideSnapshot;
				}
				return false;
			}
		}

		internal static void BeginServerSession()
		{
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			if (_active || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			if (!EndServerSession())
			{
				PortalRulesPlugin.PortalRulesLogger.LogError((object)"PortalRules identity storage retained unsaved data from the previous session; the new session will remain unavailable until that data can be saved.");
				return;
			}
			_active = true;
			PlayerIdentities.Clear();
			ConflictedPlayerIds.Clear();
			_portalLimitOverrides = new Dictionary<string, PortalLimitOverride>(StringComparer.Ordinal);
			_hasValidOverrideSnapshot = false;
			_identityDirty = false;
			_identityFirstDirtyUtc = DateTime.MinValue;
			_identitySaveNotBeforeUtc = DateTime.MinValue;
			_nextOverridePollUtc = DateTime.UtcNow + OverridePollingInterval;
			Interlocked.Exchange(ref _overrideReloadRequested, 0);
			Interlocked.Exchange(ref _overrideReloadAttempts, 0);
			Interlocked.Exchange(ref _overrideWatcherRestartRequested, 0);
			Interlocked.Exchange(ref _overrideReloadNotBeforeUtcTicks, 0L);
			Interlocked.Exchange(ref _overrideWatcherRestartNotBeforeUtcTicks, 0L);
			_configurationDirectory = Path.Combine(Paths.ConfigPath, "PortalRules");
			_identityFilePath = Path.Combine(_configurationDirectory, "player-identities.yml");
			_overrideFilePath = Path.Combine(_configurationDirectory, "portal-limit-overrides.yml");
			try
			{
				Directory.CreateDirectory(_configurationDirectory);
				LoadPlayerIdentities();
				EnsureOverrideTemplate();
				try
				{
					StartOverrideWatcher();
				}
				catch (Exception ex)
				{
					StopOverrideWatcher();
					Interlocked.Exchange(ref _overrideWatcherRestartRequested, 1);
					ScheduleOverrideWatcherRestart(WatcherRestartRetryDelay);
					PortalRulesPlugin.PortalRulesLogger.LogError((object)("Failed to watch portal-limit-overrides.yml; periodic reload remains active: " + ex.Message));
				}
				if (!TryReloadOverrides(logOnlyWhenChanged: false, out var _))
				{
					ScheduleOverrideReload(OverrideReloadRetryDelay);
				}
			}
			catch (Exception ex2)
			{
				StopOverrideWatcher();
				_active = false;
				PortalRulesPlugin.PortalRulesLogger.LogError((object)("Failed to initialize PortalRules account files: " + ex2.Message));
			}
			if (_active && (int)ZNet.m_onlineBackend != 0)
			{
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)"PortalRules account attribution is Steam-only. Counted portal placement will fail closed on a non-Steam backend.");
			}
		}

		internal static bool EndServerSession()
		{
			bool num = FlushPlayerIdentities();
			StopOverrideWatcher();
			_active = false;
			if (!num && _identityDirty)
			{
				PortalRulesPlugin.PortalRulesLogger.LogError((object)"PortalRules identity storage could not complete its final save; unsaved identities are being retained in memory for retry.");
				return false;
			}
			PlayerIdentities.Clear();
			ConflictedPlayerIds.Clear();
			_portalLimitOverrides = new Dictionary<string, PortalLimitOverride>(StringComparer.Ordinal);
			_hasValidOverrideSnapshot = false;
			_identityDirty = false;
			_identityFirstDirtyUtc = DateTime.MinValue;
			_identitySaveNotBeforeUtc = DateTime.MinValue;
			_nextOverridePollUtc = DateTime.MinValue;
			_configurationDirectory = "";
			_identityFilePath = "";
			_overrideFilePath = "";
			Interlocked.Exchange(ref _overrideReloadRequested, 0);
			Interlocked.Exchange(ref _overrideReloadAttempts, 0);
			Interlocked.Exchange(ref _overrideWatcherRestartRequested, 0);
			Interlocked.Exchange(ref _overrideReloadNotBeforeUtcTicks, 0L);
			Interlocked.Exchange(ref _overrideWatcherRestartNotBeforeUtcTicks, 0L);
			return true;
		}

		internal static bool Tick()
		{
			DateTime utcNow = DateTime.UtcNow;
			bool flag = !_active && _identityDirty && !string.IsNullOrEmpty(_identityFilePath);
			if (_identityDirty && utcNow >= _identitySaveNotBeforeUtc && SavePlayerIdentities(utcNow) && flag)
			{
				EndServerSession();
				if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
				{
					BeginServerSession();
				}
			}
			if (!_active)
			{
				return false;
			}
			if (Volatile.Read(in _overrideWatcherRestartRequested) != 0 && utcNow.Ticks >= Interlocked.Read(in _overrideWatcherRestartNotBeforeUtcTicks))
			{
				Interlocked.Exchange(ref _overrideWatcherRestartRequested, 0);
				try
				{
					StartOverrideWatcher();
					RequestOverrideReload();
				}
				catch (Exception ex)
				{
					PortalRulesPlugin.PortalRulesLogger.LogError((object)("Failed to restart the portal-limit-overrides.yml watcher: " + ex.Message));
					Interlocked.Exchange(ref _overrideWatcherRestartRequested, 1);
					ScheduleOverrideWatcherRestart(WatcherRestartRetryDelay);
				}
			}
			if (utcNow >= _nextOverridePollUtc)
			{
				_nextOverridePollUtc = utcNow + OverridePollingInterval;
				if (Volatile.Read(in _overrideReloadRequested) == 0)
				{
					ScheduleOverrideReload(TimeSpan.Zero);
				}
			}
			if (Volatile.Read(in _overrideReloadRequested) != 0 && utcNow.Ticks >= Interlocked.Read(in _overrideReloadNotBeforeUtcTicks))
			{
				Interlocked.Exchange(ref _overrideReloadRequested, 0);
				if (TryReloadOverrides(logOnlyWhenChanged: true, out var changed))
				{
					Interlocked.Exchange(ref _overrideReloadAttempts, 0);
					return changed;
				}
				if (Interlocked.Increment(ref _overrideReloadAttempts) <= 5)
				{
					ScheduleOverrideReload(OverrideReloadRetryDelay);
				}
			}
			return false;
		}

		internal static bool FlushPlayerIdentities()
		{
			if (!_identityDirty)
			{
				return true;
			}
			if (string.IsNullOrEmpty(_identityFilePath))
			{
				return false;
			}
			return SavePlayerIdentities(DateTime.UtcNow);
		}

		internal static bool TryRememberIdentity(long playerId, string steamId, out bool added)
		{
			added = false;
			if (!_active || playerId == 0L || !PublicPortalData.TryNormalizeSteamId64(steamId, out string steamId2))
			{
				return false;
			}
			if (ConflictedPlayerIds.Contains(playerId))
			{
				return false;
			}
			if (PlayerIdentities.TryGetValue(playerId, out string value))
			{
				if (string.Equals(value, steamId2, StringComparison.Ordinal))
				{
					return true;
				}
				ConflictedPlayerIds.Add(playerId);
				PortalRulesPlugin.PortalRulesLogger.LogError((object)($"Refused identity collision for playerID {playerId}: " + "stored SteamID64 " + value + ", authenticated SteamID64 " + steamId2 + ". The stored mapping was not overwritten and this playerID is blocked for this session."));
				return false;
			}
			if (PlayerIdentities.Count >= 16384)
			{
				PortalRulesPlugin.PortalRulesLogger.LogError((object)(string.Format("Refused playerID {0}: {1} reached ", playerId, "player-identities.yml") + $"the {16384} identity limit."));
				return false;
			}
			PlayerIdentities.Add(playerId, steamId2);
			added = true;
			MarkPlayerIdentitiesDirty(DateTime.UtcNow);
			return true;
		}

		internal static bool TryResolveSteamId(long playerId, out string steamId)
		{
			steamId = "";
			if (_active && playerId != 0L && !ConflictedPlayerIds.Contains(playerId))
			{
				return PlayerIdentities.TryGetValue(playerId, out steamId);
			}
			return false;
		}

		internal static int GetEffectivePortalLimit(string steamId, int defaultLimit)
		{
			if (!PublicPortalData.TryNormalizeSteamId64(steamId, out string steamId2))
			{
				return 0;
			}
			if (!_active || !_portalLimitOverrides.TryGetValue(steamId2, out var value))
			{
				return Math.Max(-1, Math.Min(10000, defaultLimit));
			}
			return value.PortalLimit;
		}

		internal static int GetEffectiveInvitePortalLimit(string steamId, int defaultLimit)
		{
			if (!PublicPortalData.TryNormalizeSteamId64(steamId, out string steamId2))
			{
				return 0;
			}
			int result = Math.Max(-1, Math.Min(10000, defaultLimit));
			if (!_active || !_portalLimitOverrides.TryGetValue(steamId2, out var value) || !value.InviteLimit.HasValue)
			{
				return result;
			}
			return value.InviteLimit.Value;
		}

		private static void LoadPlayerIdentities()
		{
			if (!File.Exists(_identityFilePath))
			{
				string path = _identityFilePath + ".bak";
				if (File.Exists(path) && TryReadPlayerIdentities(path, out Dictionary<long, string> identities))
				{
					ReplacePlayerIdentities(identities);
					PortalRulesPlugin.PortalRulesLogger.LogWarning((object)"Recovered missing player-identities.yml from its last valid backup.");
				}
				_identityDirty = true;
				SavePlayerIdentities(DateTime.UtcNow);
				return;
			}
			if (TryReadPlayerIdentities(_identityFilePath, out Dictionary<long, string> identities2))
			{
				ReplacePlayerIdentities(identities2);
				return;
			}
			string path2 = _identityFilePath + ".bak";
			QuarantineInvalidIdentityFile();
			if (File.Exists(path2) && TryReadPlayerIdentities(path2, out Dictionary<long, string> identities3))
			{
				ReplacePlayerIdentities(identities3);
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)"Recovered player-identities.yml from its last valid backup.");
			}
			else
			{
				PlayerIdentities.Clear();
				PortalRulesPlugin.PortalRulesLogger.LogError((object)"Could not load player-identities.yml or its backup; existing unstamped portals will remain unattributed until identities are learned again.");
			}
			_identityDirty = true;
			SavePlayerIdentities(DateTime.UtcNow);
		}

		private static bool TryReadPlayerIdentities(string path, out Dictionary<long, string> identities)
		{
			identities = new Dictionary<long, string>();
			try
			{
				if (new FileInfo(path).Length > 2097152)
				{
					throw new InvalidDataException($"file exceeds {2097152L} bytes");
				}
				PlayerIdentitiesYaml playerIdentitiesYaml = Deserializer.Deserialize<PlayerIdentitiesYaml>(File.ReadAllText(path));
				if (playerIdentitiesYaml == null || playerIdentitiesYaml.FormatVersion != 1 || playerIdentitiesYaml.Identities == null)
				{
					throw new InvalidDataException($"format_version must be {1} and identities must be present");
				}
				if (playerIdentitiesYaml.Identities.Count > 16384)
				{
					throw new InvalidDataException($"identities exceeds {16384} entries");
				}
				foreach (KeyValuePair<string, string> identity in playerIdentitiesYaml.Identities)
				{
					if (!long.TryParse(identity.Key, NumberStyles.AllowLeadingSign, CultureInfo.InvariantCulture, out var result) || result == 0L || !string.Equals(identity.Key, result.ToString(CultureInfo.InvariantCulture), StringComparison.Ordinal))
					{
						throw new InvalidDataException("identity key '" + identity.Key + "' is not a canonical nonzero playerID");
					}
					if (!PublicPortalData.TryNormalizeSteamId64(identity.Value, out string steamId) || !string.Equals(identity.Value, steamId, StringComparison.Ordinal))
					{
						throw new InvalidDataException("identity value for playerID " + identity.Key + " is not a bare SteamID64");
					}
					identities.Add(result, steamId);
				}
				return true;
			}
			catch (Exception ex)
			{
				PortalRulesPlugin.PortalRulesLogger.LogError((object)("Failed to read " + Path.GetFileName(path) + ": " + ex.Message));
				identities.Clear();
				return false;
			}
		}

		private static void ReplacePlayerIdentities(Dictionary<long, string> identities)
		{
			PlayerIdentities.Clear();
			foreach (KeyValuePair<long, string> identity in identities)
			{
				PlayerIdentities.Add(identity.Key, identity.Value);
			}
		}

		private static bool SavePlayerIdentities(DateTime nowUtc)
		{
			try
			{
				WriteAtomicFile(_identityFilePath, SerializePlayerIdentities(), _identityFilePath + ".bak");
				_identityDirty = false;
				_identityFirstDirtyUtc = DateTime.MinValue;
				_identitySaveNotBeforeUtc = DateTime.MinValue;
				return true;
			}
			catch (Exception ex)
			{
				_identityDirty = true;
				_identityFirstDirtyUtc = nowUtc;
				_identitySaveNotBeforeUtc = nowUtc + IdentitySaveRetryDelay;
				PortalRulesPlugin.PortalRulesLogger.LogError((object)("Failed to save player-identities.yml; retrying later: " + ex.Message));
				return false;
			}
		}

		private static string SerializePlayerIdentities()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("# AUTO-GENERATED by PortalRules. Do not edit while the server is running.");
			stringBuilder.Append("format_version: ").AppendLine(1.ToString(CultureInfo.InvariantCulture));
			if (PlayerIdentities.Count == 0)
			{
				stringBuilder.AppendLine("identities: {}");
				return stringBuilder.ToString();
			}
			stringBuilder.AppendLine("identities:");
			foreach (KeyValuePair<long, string> item in PlayerIdentities.OrderBy<KeyValuePair<long, string>, long>((KeyValuePair<long, string> pair) => pair.Key))
			{
				stringBuilder.Append("  \"").Append(item.Key.ToString(CultureInfo.InvariantCulture)).Append("\": \"")
					.Append(item.Value)
					.AppendLine("\"");
			}
			return stringBuilder.ToString();
		}

		private static void MarkPlayerIdentitiesDirty(DateTime nowUtc)
		{
			if (!_identityDirty)
			{
				_identityFirstDirtyUtc = nowUtc;
			}
			_identityDirty = true;
			DateTime dateTime = nowUtc + IdentitySaveDebounce;
			DateTime dateTime2 = _identityFirstDirtyUtc + IdentityMaximumSaveDelay;
			_identitySaveNotBeforeUtc = ((dateTime < dateTime2) ? dateTime : dateTime2);
		}

		private static void QuarantineInvalidIdentityFile()
		{
			if (File.Exists(_identityFilePath))
			{
				string text = DateTime.UtcNow.ToString("yyyyMMdd-HHmmss", CultureInfo.InvariantCulture);
				string text2 = _identityFilePath + ".invalid-" + text;
				if (File.Exists(text2))
				{
					text2 = text2 + "-" + Guid.NewGuid().ToString("N");
				}
				File.Move(_identityFilePath, text2);
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("Moved invalid player-identities.yml to " + Path.GetFileName(text2) + "."));
			}
		}

		private static void EnsureOverrideTemplate()
		{
			if (!File.Exists(_overrideFilePath))
			{
				WriteAtomicFile(_overrideFilePath, "# PortalRules per-Steam-account portal limit overrides.\n# Keys must be bare 17-digit SteamID64 values.\n# Each value is: portal_limit OR portal_limit, invite_limit\n# portal_limit: -1 = unlimited, 0 = block new counted portals, 1..10000 = custom limit.\n# invite_limit: -1 = unlimited, 0 = disable Invite and return existing eligible Invite portals to the Builder's Personal access, 1..10000 = custom limit.\n# If invite_limit is omitted, the current server config value is used dynamically.\n# A trailing comma is invalid; omit the comma and second value together.\n# Schema examples:\n# format_version: 2\n# overrides:\n#   \"76561198000000000\": 10    ## portal_limit; invite_limit uses server config\n#   \"76561198000000001\": 10, 1 ## portal_limit, invite_limit\n# format_version 1 remains unsupported; no legacy migration is performed.\nformat_version: 2\noverrides: {}\n", null);
			}
		}

		private static bool TryReloadOverrides(bool logOnlyWhenChanged, out bool changed)
		{
			changed = false;
			if (!File.Exists(_overrideFilePath))
			{
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)"portal-limit-overrides.yml is missing; retaining the last valid overrides. Use 'overrides: {}' to clear them.");
				return false;
			}
			try
			{
				if (new FileInfo(_overrideFilePath).Length > 524288)
				{
					throw new InvalidDataException($"file exceeds {524288L} bytes");
				}
				PortalLimitOverridesYaml portalLimitOverridesYaml = Deserializer.Deserialize<PortalLimitOverridesYaml>(File.ReadAllText(_overrideFilePath));
				if (portalLimitOverridesYaml == null || portalLimitOverridesYaml.FormatVersion != 2 || portalLimitOverridesYaml.Overrides == null)
				{
					throw new InvalidDataException($"format_version must be {2} and overrides must be present");
				}
				if (portalLimitOverridesYaml.Overrides.Count > 4096)
				{
					throw new InvalidDataException($"overrides exceeds {4096} entries");
				}
				Dictionary<string, PortalLimitOverride> dictionary = new Dictionary<string, PortalLimitOverride>(StringComparer.Ordinal);
				foreach (KeyValuePair<string, string> @override in portalLimitOverridesYaml.Overrides)
				{
					if (!PublicPortalData.TryNormalizeSteamId64(@override.Key, out string steamId) || !string.Equals(@override.Key, steamId, StringComparison.Ordinal))
					{
						throw new InvalidDataException("override key '" + @override.Key + "' is not a bare SteamID64");
					}
					string[] array = (@override.Value ?? "").Split(new char[1] { ',' });
					int num = array.Length;
					bool flag = ((num < 1 || num > 2) ? true : false);
					if (flag || !int.TryParse(array[0].Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
					{
						throw new InvalidDataException("override for " + @override.Key + " must be 'portal_limit' or 'portal_limit, invite_limit'");
					}
					ValidateOverrideLimit(@override.Key, "portal_limit", result);
					int? inviteLimit = null;
					if (array.Length == 2)
					{
						if (!int.TryParse(array[1].Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2))
						{
							throw new InvalidDataException("override for " + @override.Key + " must be 'portal_limit' or 'portal_limit, invite_limit'");
						}
						ValidateOverrideLimit(@override.Key, "invite_limit", result2);
						inviteLimit = result2;
					}
					dictionary.Add(steamId, new PortalLimitOverride(result, inviteLimit));
				}
				changed = !_hasValidOverrideSnapshot || !DictionariesEqual(_portalLimitOverrides, dictionary);
				_portalLimitOverrides = dictionary;
				_hasValidOverrideSnapshot = true;
				if (!logOnlyWhenChanged | changed)
				{
					PortalRulesPlugin.PortalRulesLogger.LogInfo((object)$"Loaded {_portalLimitOverrides.Count} account limit override(s).");
				}
				return true;
			}
			catch (Exception ex)
			{
				PortalRulesPlugin.PortalRulesLogger.LogError((object)("Failed to reload portal-limit-overrides.yml; retaining the last valid overrides: " + ex.Message));
				return false;
			}
		}

		private static void ValidateOverrideLimit(string steamId, string fieldName, int value)
		{
			if (value < -1 || value > 10000)
			{
				throw new InvalidDataException(fieldName + " override for " + steamId + " must be between -1 and " + 10000);
			}
		}

		private static bool DictionariesEqual(Dictionary<string, PortalLimitOverride> left, Dictionary<string, PortalLimitOverride> right)
		{
			if (left.Count != right.Count)
			{
				return false;
			}
			foreach (KeyValuePair<string, PortalLimitOverride> item in left)
			{
				if (!right.TryGetValue(item.Key, out var value) || !value.Matches(item.Value))
				{
					return false;
				}
			}
			return true;
		}

		private static void StartOverrideWatcher()
		{
			StopOverrideWatcher();
			_overrideWatcher = new FileSystemWatcher(_configurationDirectory, "portal-limit-overrides.yml")
			{
				IncludeSubdirectories = false,
				NotifyFilter = (NotifyFilters.FileName | NotifyFilters.Size | NotifyFilters.LastWrite)
			};
			_overrideWatcher.Changed += OnOverrideFileChanged;
			_overrideWatcher.Created += OnOverrideFileChanged;
			_overrideWatcher.Deleted += OnOverrideFileChanged;
			_overrideWatcher.Renamed += OnOverrideFileRenamed;
			_overrideWatcher.Error += OnOverrideWatcherError;
			_overrideWatcher.EnableRaisingEvents = true;
		}

		private static void StopOverrideWatcher()
		{
			if (_overrideWatcher != null)
			{
				_overrideWatcher.EnableRaisingEvents = false;
				_overrideWatcher.Changed -= OnOverrideFileChanged;
				_overrideWatcher.Created -= OnOverrideFileChanged;
				_overrideWatcher.Deleted -= OnOverrideFileChanged;
				_overrideWatcher.Renamed -= OnOverrideFileRenamed;
				_overrideWatcher.Error -= OnOverrideWatcherError;
				_overrideWatcher.Dispose();
				_overrideWatcher = null;
			}
		}

		private static void OnOverrideFileChanged(object sender, FileSystemEventArgs args)
		{
			RequestOverrideReload();
		}

		private static void OnOverrideFileRenamed(object sender, RenamedEventArgs args)
		{
			RequestOverrideReload();
		}

		private static void OnOverrideWatcherError(object sender, ErrorEventArgs args)
		{
			PortalRulesPlugin.PortalRulesLogger.LogError((object)("The portal-limit-overrides.yml watcher failed and will be restarted: " + args.GetException().Message));
			Interlocked.Exchange(ref _overrideWatcherRestartRequested, 1);
			ScheduleOverrideWatcherRestart(WatcherRestartRetryDelay);
			RequestOverrideReload();
		}

		private static void RequestOverrideReload()
		{
			Interlocked.Exchange(ref _overrideReloadAttempts, 0);
			ScheduleOverrideReload(OverrideReloadDebounce);
		}

		private static void ScheduleOverrideReload(TimeSpan delay)
		{
			Interlocked.Exchange(ref _overrideReloadNotBeforeUtcTicks, (DateTime.UtcNow + delay).Ticks);
			Interlocked.Exchange(ref _overrideReloadRequested, 1);
		}

		private static void ScheduleOverrideWatcherRestart(TimeSpan delay)
		{
			Interlocked.Exchange(ref _overrideWatcherRestartNotBeforeUtcTicks, (DateTime.UtcNow + delay).Ticks);
		}

		internal static void WriteAtomicFile(string path, string content, string? backupPath)
		{
			string? obj = Path.GetDirectoryName(path) ?? throw new InvalidOperationException("Target directory is unavailable.");
			Directory.CreateDirectory(obj);
			string text = Path.Combine(obj, "." + Path.GetFileName(path) + "." + Guid.NewGuid().ToString("N") + ".tmp");
			try
			{
				using (FileStream fileStream = new FileStream(text, FileMode.CreateNew, FileAccess.Write, FileShare.None))
				{
					using StreamWriter streamWriter = new StreamWriter(fileStream, Utf8WithoutBom);
					streamWriter.Write(content);
					streamWriter.Flush();
					fileStream.Flush(flushToDisk: true);
				}
				if (File.Exists(path))
				{
					try
					{
						File.Replace(text, path, backupPath, ignoreMetadataErrors: true);
						return;
					}
					catch (PlatformNotSupportedException)
					{
						ReplaceUsingMoves(text, path, backupPath);
						return;
					}
					catch (NotSupportedException)
					{
						ReplaceUsingMoves(text, path, backupPath);
						return;
					}
					catch (IOException) when (Path.DirectorySeparatorChar == '/')
					{
						ReplaceUsingMoves(text, path, backupPath);
						return;
					}
				}
				File.Move(text, path);
			}
			finally
			{
				if (File.Exists(text))
				{
					File.Delete(text);
				}
			}
		}

		private static void ReplaceUsingMoves(string temporaryPath, string path, string? backupPath)
		{
			string text = backupPath ?? (path + ".replace-backup");
			if (File.Exists(text))
			{
				File.Delete(text);
			}
			File.Move(path, text);
			try
			{
				File.Move(temporaryPath, path);
				if (backupPath == null && File.Exists(text))
				{
					File.Delete(text);
				}
			}
			catch
			{
				if (!File.Exists(path) && File.Exists(text))
				{
					File.Move(text, path);
				}
				throw;
			}
		}
	}
	internal static class PortalRulesLocalization
	{
		internal const string PortalDeniedToken = "sighsorry_portalrules_portal_denied";

		internal const string MissingGlobalKeyToken = "sighsorry_portalrules_missing_global_key";

		internal const string OwnedTokenPrefix = "sighsorry_portalrules_";

		private const string EnglishLanguage = "English";

		private const string KoreanLanguage = "Korean";

		private const string ExternalFilePrefix = "PortalRules.";

		private const string EmbeddedResourcePrefix = "PortalRules.translations.";

		private const long MaxExternalTranslationFileBytes = 1048576L;

		private static readonly object Sync = new object();

		private static readonly StringComparer FileSystemPathComparer = ((Path.DirectorySeparatorChar == '\\') ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal);

		private static readonly IComparer<string> DeterministicPathComparer = Comparer<string>.Create(delegate(string left, string right)
		{
			int num = FileSystemPathComparer.Compare(left, right);
			return (num == 0) ? StringComparer.Ordinal.Compare(left, right) : num;
		});

		private static readonly Dictionary<string, string> BuiltInEnglish = new Dictionary<string, string>(StringComparer.Ordinal)
		{
			["sighsorry_portalrules_portal_denied"] = "You cannot use this portal.",
			["sighsorry_portalrules_missing_global_key"] = "You need \"{0}\"."
		};

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

		private static readonly HashSet<string> LoggedFormatFailures = new HashSet<string>(StringComparer.Ordinal);

		private static Dictionary<string, string> _english = new Dictionary<string, string>(BuiltInEnglish, StringComparer.Ordinal);

		private static Dictionary<string, string> _safeEnglish = new Dictionary<string, string>(BuiltInEnglish, StringComparer.Ordinal);

		private static Dictionary<string, string> _embeddedKorean = new Dictionary<string, string>(StringComparer.Ordinal);

		private static Dictionary<string, string> _active = new Dictionary<string, string>(BuiltInEnglish, StringComparer.Ordinal);

		private static string _activeLanguage = "English";

		private static bool _initialized;

		private static bool _addWordResolved;

		private static bool _addWordFailureLogged;

		private static MethodInfo? _addWordMethod;

		internal static void Initialize()
		{
			lock (Sync)
			{
				if (_initialized)
				{
					return;
				}
				try
				{
					Dictionary<string, string> dictionary = new Dictionary<string, string>(BuiltInEnglish, StringComparer.Ordinal);
					if (TryReadEmbedded("English", out Dictionary<string, string> translations))
					{
						Merge(dictionary, translations);
					}
					Dictionary<string, string> dictionary2 = new Dictionary<string, string>(dictionary, StringComparer.Ordinal);
					Dictionary<string, string> dictionary3 = new Dictionary<string, string>(StringComparer.Ordinal);
					if (TryReadEmbedded("Korean", out Dictionary<string, string> translations2))
					{
						Merge(dictionary3, translations2);
					}
					Dictionary<string, Dictionary<string, string>> dictionary4 = LoadExternalTranslations();
					if (dictionary4.TryGetValue("English", out Dictionary<string, string> value))
					{
						Merge(dictionary2, value);
					}
					_english = dictionary2;
					_safeEnglish = dictionary;
					_embeddedKorean = dictionary3;
					ExternalTranslations.Clear();
					foreach (KeyValuePair<string, Dictionary<string, string>> item in dictionary4)
					{
						ExternalTranslations[item.Key] = item.Value;
					}
				}
				catch (Exception arg)
				{
					PortalRulesPlugin.PortalRulesLogger.LogError((object)$"PortalRules localization initialization failed; using built-in English: {arg}");
					ResetToBuiltInEnglish();
				}
				finally
				{
					_initialized = true;
				}
			}
			ApplyCurrentLanguage();
		}

		internal static string Translate(string token, params string[] args)
		{
			EnsureInitialized();
			string originalToken = (token ?? string.Empty).Trim();
			string text = NormalizeToken(token);
			if (text.Length == 0)
			{
				return string.Empty;
			}
			string activeLanguage;
			string value;
			string text2;
			bool flag2;
			lock (Sync)
			{
				activeLanguage = _activeLanguage;
				bool flag = _safeEnglish.TryGetValue(text, out value);
				if (!flag)
				{
					value = (BuiltInEnglish.TryGetValue(text, out string value2) ? value2 : text);
				}
				string value3;
				bool num = _active.TryGetValue(text, out value3);
				text2 = (num ? value3 : value);
				flag2 = num || flag;
			}
			string[] array = args ?? Array.Empty<string>();
			if (!text.StartsWith("sighsorry_portalrules_", StringComparison.Ordinal) || !flag2)
			{
				return TranslateVanilla(originalToken, text, array);
			}
			try
			{
				CultureInfo currentCulture = CultureInfo.CurrentCulture;
				object[] args2 = array;
				return string.Format(currentCulture, text2, args2);
			}
			catch (FormatException exception)
			{
				LogFormatFailureOnce(activeLanguage, text, exception);
				if (!string.Equals(text2, value, StringComparison.Ordinal))
				{
					try
					{
						CultureInfo currentCulture2 = CultureInfo.CurrentCulture;
						string format = value;
						object[] args2 = array;
						return string.Format(currentCulture2, format, args2);
					}
					catch (FormatException exception2)
					{
						LogFormatFailureOnce("English", text, exception2);
					}
				}
				return value;
			}
			catch (Exception ex)
			{
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("Could not translate PortalRules token '" + text + "'; using English text: " + ex.Message));
				return value;
			}
		}

		internal static void ApplyCurrentLanguage()
		{
			try
			{
				Localization instance = Localization.instance;
				string selectedLanguage = GetSelectedLanguage(instance);
				ApplyLanguage(instance, selectedLanguage);
			}
			catch (Exception ex)
			{
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("Could not apply the current PortalRules language; keeping English: " + ex.Message));
				SetActiveLanguage("English");
			}
		}

		internal static void ApplyLanguage(Localization? localization, string? language)
		{
			EnsureInitialized();
			string text = language?.Trim() ?? string.Empty;
			string text2 = ((text.Length == 0) ? "English" : text);
			Dictionary<string, string> dictionary = BuildActiveLanguage(text2);
			lock (Sync)
			{
				_activeLanguage = text2;
				_active = dictionary;
			}
			RegisterActiveTranslations(localization, dictionary);
		}

		private static void EnsureInitialized()
		{
			bool initialized;
			lock (Sync)
			{
				initialized = _initialized;
			}
			if (!initialized)
			{
				Initialize();
			}
		}

		private static Dictionary<string, string> BuildActiveLanguage(string language)
		{
			lock (Sync)
			{
				Dictionary<string, string> dictionary = new Dictionary<string, string>(_english, StringComparer.Ordinal);
				if (string.Equals(language, "Korean", StringComparison.OrdinalIgnoreCase))
				{
					Merge(dictionary, _embeddedKorean);
				}
				if (!string.Equals(language, "English", StringComparison.OrdinalIgnoreCase) && ExternalTranslations.TryGetValue(language, out Dictionary<string, string> value))
				{
					Merge(dictionary, value);
				}
				return dictionary;
			}
		}

		private static void SetActiveLanguage(string language)
		{
			Dictionary<string, string> active = BuildActiveLanguage(language);
			lock (Sync)
			{
				_activeLanguage = language;
				_active = active;
			}
		}

		private static string GetSelectedLanguage(Localization? localization)
		{
			if (localization == null)
			{
				return "English";
			}
			try
			{
				string selectedLanguage = localization.GetSelectedLanguage();
				return string.IsNullOrWhiteSpace(selectedLanguage) ? "English" : selectedLanguage.Trim();
			}
			catch
			{
				return "English";
			}
		}

		private static Dictionary<string, Dictionary<string, string>> LoadExternalTranslations()
		{
			Dictionary<string, List<string>> source = DiscoverExternalFiles();
			Dictionary<string, Dictionary<string, string>> dictionary = new Dictionary<string, Dictionary<string, string>>(StringComparer.OrdinalIgnoreCase);
			foreach (KeyValuePair<string, List<string>> item in source.OrderBy<KeyValuePair<string, List<string>>, string>((KeyValuePair<string, List<string>> pair) => pair.Key, StringComparer.OrdinalIgnoreCase).ThenBy<KeyValuePair<string, List<string>>, string>((KeyValuePair<string, List<string>> pair) => pair.Key, StringComparer.Ordinal))
			{
				Dictionary<string, string> dictionary2 = new Dictionary<string, string>(StringComparer.Ordinal);
				Dictionary<string, string> dictionary3 = new Dictionary<string, string>(StringComparer.Ordinal);
				foreach (string item2 in item.Value.OrderBy<string, string>((string result) => result, StringComparer.OrdinalIgnoreCase).ThenBy<string, string>((string result) => result, StringComparer.Ordinal))
				{
					if (!TryReadFile(item2, out Dictionary<string, string> translations))
					{
						continue;
					}
					foreach (KeyValuePair<string, string> item3 in translations)
					{
						if (dictionary3.TryGetValue(item3.Key, out var value))
						{
							PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("Duplicate PortalRules translation token '" + item3.Key + "' for language '" + item.Key + "' in '" + value + "' and '" + item2 + "'; the later ordinal path wins."));
						}
						dictionary2[item3.Key] = item3.Value;
						dictionary3[item3.Key] = item2;
					}
				}
				if (dictionary2.Count > 0)
				{
					dictionary[item.Key] = dictionary2;
				}
			}
			return dictionary;
		}

		private static Dictionary<string, List<string>> DiscoverExternalFiles()
		{
			Dictionary<string, List<string>> dictionary = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);
			string bepInExRootPath = Paths.BepInExRootPath;
			if (string.IsNullOrWhiteSpace(bepInExRootPath) || !Directory.Exists(bepInExRootPath))
			{
				return dictionary;
			}
			Stack<string> stack = new Stack<string>();
			HashSet<string> hashSet = new HashSet<string>(FileSystemPathComparer);
			stack.Push(Path.GetFullPath(bepInExRootPath));
			while (stack.Count > 0)
			{
				string text = stack.Pop();
				if (!hashSet.Add(text))
				{
					continue;
				}
				string[] array;
				try
				{
					array = Directory.GetFiles(text);
				}
				catch (Exception ex)
				{
					PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("Could not inspect PortalRules translation directory '" + text + "': " + ex.Message));
					array = Array.Empty<string>();
				}
				string[] array2 = array;
				foreach (string path in array2)
				{
					if (TryGetExternalLanguage(path, out string language))
					{
						if (!dictionary.TryGetValue(language, out var value))
						{
							value = (dictionary[language] = new List<string>());
						}
						value.Add(Path.GetFullPath(path));
					}
				}
				string[] directories;
				try
				{
					directories = Directory.GetDirectories(text);
				}
				catch (Exception ex2)
				{
					PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("Could not inspect child directories below '" + text + "': " + ex2.Message));
					continue;
				}
				Array.Sort(directories, DeterministicPathComparer);
				for (int num = directories.Length - 1; num >= 0; num--)
				{
					string text2 = directories[num];
					try
					{
						if ((File.GetAttributes(text2) & FileAttributes.ReparsePoint) == 0)
						{
							stack.Push(Path.GetFullPath(text2));
						}
					}
					catch (Exception ex3)
					{
						PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("Could not inspect PortalRules translation path '" + text2 + "': " + ex3.Message));
					}
				}
			}
			return dictionary;
		}

		private static bool TryGetExternalLanguage(string path, out string language)
		{
			language = string.Empty;
			string extension = Path.GetExtension(path);
			if (!string.Equals(extension, ".yml", StringComparison.OrdinalIgnoreCase) && !string.Equals(extension, ".yaml", StringComparison.OrdinalIgnoreCase) && !string.Equals(extension, ".json", StringComparison.OrdinalIgnoreCase))
			{
				return false;
			}
			string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(path);
			if (!fileNameWithoutExtension.StartsWith("PortalRules.", StringComparison.OrdinalIgnoreCase))
			{
				return false;
			}
			language = fileNameWithoutExtension.Substring("PortalRules.".Length);
			if (string.IsNullOrWhiteSpace(language) || language.Length != language.Trim().Length || language.IndexOf('.') >= 0)
			{
				language = string.Empty;
				return false;
			}
			return true;
		}

		private static bool TryReadEmbedded(string language, out Dictionary<string, string> translations)
		{
			translations = new Dictionary<string, string>(StringComparer.Ordinal);
			string text = "PortalRules.translations." + language + ".yml";
			try
			{
				using Stream stream = typeof(PortalRulesLocalization).Assembly.GetManifestResourceStream(text);
				if (stream == null)
				{
					PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("Embedded PortalRules translation '" + text + "' was not found."));
					return false;
				}
				using StreamReader streamReader = new StreamReader(stream, Encoding.UTF8, detectEncodingFromByteOrderMarks: true);
				return TryParseTranslations(streamReader.ReadToEnd(), text, out translations);
			}
			catch (Exception ex)
			{
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("Could not read embedded PortalRules translation '" + text + "': " + ex.Message));
				return false;
			}
		}

		private static bool TryReadFile(string path, out Dictionary<string, string> translations)
		{
			translations = new Dictionary<string, string>(StringComparer.Ordinal);
			try
			{
				long length = new FileInfo(path).Length;
				if (length > 1048576)
				{
					PortalRulesPlugin.PortalRulesLogger.LogWarning((object)($"PortalRules translation '{path}' is {length} bytes and exceeds the " + $"{1048576L}-byte limit; the file was ignored."));
					return false;
				}
				return TryParseTranslations(File.ReadAllText(path), path, out translations);
			}
			catch (Exception ex)
			{
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("Could not read PortalRules translation '" + path + "': " + ex.Message));
				return false;
			}
		}

		private static bool TryParseTranslations(string content, string source, out Dictionary<string, string> translations)
		{
			translations = new Dictionary<string, string>(StringComparer.Ordinal);
			if (string.IsNullOrWhiteSpace(content))
			{
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("PortalRules translation '" + source + "' is empty and was ignored."));
				return false;
			}
			try
			{
				YamlStream yamlStream = new YamlStream();
				using StringReader input = new StringReader(content);
				yamlStream.Load(input);
				if (yamlStream.Documents.Count != 1 || !(yamlStream.Documents[0].RootNode is YamlMappingNode yamlMappingNode))
				{
					PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("PortalRules translation '" + source + "' must contain exactly one mapping document."));
					return false;
				}
				foreach (KeyValuePair<YamlNode, YamlNode> child in yamlMappingNode.Children)
				{
					if (!(child.Key is YamlScalarNode yamlScalarNode) || string.IsNullOrWhiteSpace(yamlScalarNode.Value))
					{
						PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("PortalRules translation '" + source + "' contains an empty or non-scalar token and was ignored."));
						continue;
					}
					string text = NormalizeToken(yamlScalarNode.Value);
					if (!text.StartsWith("sighsorry_portalrules_", StringComparison.Ordinal))
					{
						PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("Translation token '" + yamlScalarNode.Value + "' in '" + source + "' is not owned by PortalRules and was ignored."));
						continue;
					}
					if (!(child.Value is YamlScalarNode yamlScalarNode2) || string.IsNullOrWhiteSpace(yamlScalarNode2.Value))
					{
						PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("PortalRules translation token '" + text + "' in '" + source + "' has no scalar text and was ignored."));
						continue;
					}
					if (translations.ContainsKey(text))
					{
						PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("Duplicate PortalRules translation token '" + text + "' inside '" + source + "'; the later value wins."));
					}
					translations[text] = yamlScalarNode2.Value;
				}
				return translations.Count > 0;
			}
			catch (Exception ex)
			{
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("Could not parse PortalRules translation '" + source + "': " + ex.Message));
				translations.Clear();
				return false;
			}
		}

		private static string NormalizeToken(string? token)
		{
			string text = (token ?? string.Empty).Trim();
			if (!text.StartsWith("$", StringComparison.Ordinal))
			{
				return text;
			}
			return text.Substring(1);
		}

		private static string TranslateVanilla(string originalToken, string normalizedToken, string[] args)
		{
			Localization instance = Localization.instance;
			if (instance == null)
			{
				return originalToken;
			}
			string text = (originalToken.StartsWith("$", StringComparison.Ordinal) ? originalToken : ("$" + normalizedToken));
			try
			{
				return instance.Localize(text, args);
			}
			catch (Exception ex)
			{
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("Could not delegate localization token '" + text + "' to Valheim: " + ex.Message));
				return originalToken;
			}
		}

		private static void RegisterActiveTranslations(Localization? localization, IReadOnlyDictionary<string, string> translations)
		{
			if (localization == null)
			{
				return;
			}
			MethodInfo methodInfo = ResolveAddWord();
			if (methodInfo == null)
			{
				LogAddWordFailureOnce("Localization.AddWord(string, string) could not be resolved; PortalRules.Translate remains available.");
				return;
			}
			foreach (KeyValuePair<string, string> translation in translations)
			{
				try
				{
					methodInfo.Invoke(localization, new object[2] { translation.Key, translation.Value });
				}
				catch (Exception ex)
				{
					PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("Could not register PortalRules localization token '" + translation.Key + "' through Localization.AddWord: " + ex.GetBaseException().Message));
				}
			}
		}

		private static MethodInfo? ResolveAddWord()
		{
			lock (Sync)
			{
				if (_addWordResolved)
				{
					return _addWordMethod;
				}
				_addWordResolved = true;
				try
				{
					_addWordMethod = AccessTools.DeclaredMethod(typeof(Localization), "AddWord", new Type[2]
					{
						typeof(string),
						typeof(string)
					}, (Type[])null);
				}
				catch (Exception ex)
				{
					LogAddWordFailureOnce("Localization.AddWord binding failed: " + ex.Message);
				}
				return _addWordMethod;
			}
		}

		private static void LogAddWordFailureOnce(string message)
		{
			lock (Sync)
			{
				if (_addWordFailureLogged)
				{
					return;
				}
				_addWordFailureLogged = true;
			}
			PortalRulesPlugin.PortalRulesLogger.LogWarning((object)message);
		}

		private static void Merge(IDictionary<string, string> destination, IReadOnlyDictionary<string, string> source)
		{
			foreach (KeyValuePair<string, string> item in source)
			{
				destination[item.Key] = item.Value;
			}
		}

		private static void ResetToBuiltInEnglish()
		{
			lock (Sync)
			{
				_english = new Dictionary<string, string>(BuiltInEnglish, StringComparer.Ordinal);
				_safeEnglish = new Dictionary<string, string>(BuiltInEnglish, StringComparer.Ordinal);
				_embeddedKorean = new Dictionary<string, string>(StringComparer.Ordinal);
				_active = new Dictionary<string, string>(BuiltInEnglish, StringComparer.Ordinal);
				_activeLanguage = "English";
				ExternalTranslations.Clear();
			}
		}

		private static void LogFormatFailureOnce(string language, string token, FormatException exception)
		{
			string item = language + "\n" + token;
			lock (Sync)
			{
				if (!LoggedFormatFailures.Add(item))
				{
					return;
				}
			}
			PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("Invalid format string for PortalRules token '" + token + "' in language '" + language + "'; using the English fallback: " + exception.Message));
		}
	}
	[HarmonyPatch(typeof(Localization), "SetupLanguage")]
	internal static class PortalRulesLocalizationSetupLanguagePatch
	{
		private static void Postfix(Localization __instance, string language)
		{
			try
			{
				PortalRulesLocalization.ApplyLanguage(__instance, language);
			}
			catch (Exception ex)
			{
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("Could not apply PortalRules translations after a language change: " + ex.Message));
			}
		}
	}
	[HarmonyPatch(typeof(FejdStartup), "SetupGui")]
	internal static class PortalRulesLocalizationSetupGuiPatch
	{
		private static void Postfix()
		{
			try
			{
				PortalRulesLocalization.ApplyCurrentLanguage();
			}
			catch (Exception ex)
			{
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("Could not apply PortalRules translations while setting up the GUI: " + ex.Message));
			}
		}
	}
	internal readonly struct PortalRulesMessage
	{
		private const string TokenPrefix = "$sighsorry_portalrules_";

		private const int MaximumTokenLength = 128;

		private const int MaximumArgumentCount = 8;

		private const int MaximumArgumentLength = 512;

		internal static readonly PortalRulesMessage Empty = new PortalRulesMessage("");

		internal readonly string Token;

		internal readonly string[] Arguments;

		internal bool IsEmpty => Token.Length == 0;

		internal PortalRulesMessage(string token, params string[] arguments)
		{
			Token = NormalizeToken(token);
			Arguments = SanitizeArguments(arguments);
		}

		internal string Localize()
		{
			if (IsEmpty)
			{
				return string.Empty;
			}
			string[] array = new string[Arguments.Length];
			for (int i = 0; i < Arguments.Length; i++)
			{
				string text = Arguments[i];
				array[i] = (IsNestedAccessModeToken(text) ? PortalRulesLocalization.Translate(text) : StringExtensionMethods.RemoveRichTextTags(text));
			}
			return PortalRulesLocalization.Translate(Token, array);
		}

		internal void Write(ZPackage package)
		{
			package.Write(Token);
			package.Write(Arguments.Length);
			string[] arguments = Arguments;
			foreach (string text in arguments)
			{
				package.Write(text);
			}
		}

		internal static bool TryRead(ZPackage package, out PortalRulesMessage message)
		{
			message = Empty;
			string text = package.ReadString();
			int num = package.ReadInt();
			if (text.Length == 0 && num == 0)
			{
				message = Empty;
				return true;
			}
			if (!IsValidToken(text) || num < 0 || num > 8)
			{
				return false;
			}
			string[] array = new string[num];
			for (int i = 0; i < num; i++)
			{
				string text2 = package.ReadString();
				if (!IsValidArgument(text2))
				{
					return false;
				}
				array[i] = text2;
			}
			message = new PortalRulesMessage(text, array);
			return true;
		}

		private static string NormalizeToken(string? token)
		{
			string text = (token ?? string.Empty).Trim();
			if (text.Length == 0)
			{
				return string.Empty;
			}
			if (!text.StartsWith("$", StringComparison.Ordinal))
			{
				text = "$" + text;
			}
			if (!IsValidToken(text))
			{
				return string.Empty;
			}
			return text;
		}

		private static string[] SanitizeArguments(string[]? arguments)
		{
			if (arguments == null || arguments.Length == 0)
			{
				return Array.Empty<string>();
			}
			int num = Math.Min(arguments.Length, 8);
			string[] array = new string[num];
			for (int i = 0; i < num; i++)
			{
				string text = arguments[i] ?? string.Empty;
				if (text.Length > 512)
				{
					text = text.Substring(0, 512);
				}
				array[i] = RemoveControlCharacters(text);
			}
			return array;
		}

		private static bool IsValidToken(string token)
		{
			if (token.Length <= "$sighsorry_portalrules_".Length || token.Length > 128 || !token.StartsWith("$sighsorry_portalrules_", StringComparison.Ordinal))
			{
				return false;
			}
			for (int i = "$sighsorry_portalrules_".Length; i < token.Length; i++)
			{
				char c = token[i];
				switch (c)
				{
				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':
					continue;
				}
				if (c < '0' || c > '9')
				{
					return false;
				}
			}
			return true;
		}

		private static bool IsValidArgument(string argument)
		{
			if (argument.Length <= 512)
			{
				return argument.IndexOfAny(new char[3] { '\r', '\n', '\0' }) < 0;
			}
			return false;
		}

		private static bool IsNestedAccessModeToken(string token)
		{
			switch (token)
			{
			case "$sighsorry_portalrules_access_mode_personal":
			case "$sighsorry_portalrules_access_mode_admin":
			case "$sighsorry_portalrules_access_mode_public":
			case "$sighsorry_portalrules_access_mode_invite":
			case "$sighsorry_portalrules_access_mode_clan":
			case "$sighsorry_portalrules_access_mode_tagged":
				return true;
			default:
				return false;
			}
		}

		private static string RemoveControlCharacters(string value)
		{
			char[] array = null;
			int num = 0;
			foreach (char c in value)
			{
				if (char.IsControl(c))
				{
					if (array == null)
					{
						array = value.ToCharArray();
					}
					continue;
				}
				if (array != null)
				{
					array[num] = c;
				}
				num++;
			}
			if (array != null)
			{
				return new string(array, 0, num);
			}
			return value;
		}
	}
	internal static class PublicPortalConfig
	{
		public static ConfigEntry<PortalRulesPlugin.Toggle> LimitToVanillaPortals;

		public static ConfigEntry<PortalRulesPlugin.Toggle> EnablePortalMap;

		public static ConfigEntry<KeyboardShortcut> ToggleAccessiblePortalsKey;

		public static ConfigEntry<float> AutoCloseGraceSeconds;

		public static ConfigEntry<int> PortalMapWheelZoomMultiplier;

		public static ConfigEntry<PortalRulesPlugin.Toggle> FavoritePortalListCollapsed;

		public static ConfigEntry<KeyboardShortcut> ToggleAccessKey;

		public static ConfigEntry<int> PublicAccessDurationSeconds;

		public static ConfigEntry<int> MaxInvitePortalsPerAccount;

		public static ConfigEntry<float> InviteDepartureCooldownHours;

		public static ConfigEntry<float> InviteArrivalCooldownHours;

		public static ConfigEntry<int> MaxClanPortalsPerClan;

		public static ConfigEntry<PortalRulesPlugin.Toggle> EnableAccountPortalLimit;

		public static ConfigEntry<int> MaxPortalsPerAccount;

		public static ConfigEntry<string> CountedPortalPrefabs;

		public static ConfigEntry<PublicPortalTravelCostScope> TravelCostScope;

		public static ConfigEntry<int> BaseCoinCost;

		public static ConfigEntry<float> BaseFareIncludedDistanceMeters;

		public static ConfigEntry<float> CoinsPerKilometer;

		public static void Init(PortalRulesPlugin plugin)
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Expected O, but got Unknown
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Expected O, but got Unknown
			//IL_01c2: 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_0241: Expected O, but got Unknown
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b8: Expected O, but got Unknown
			//IL_02e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_030e: Expected O, but got Unknown
			//IL_033c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0364: Expected O, but got Unknown
			//IL_03c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e5: Expected O, but got Unknown
			//IL_0445: Unknown result type (might be due to invalid IL or missing references)
			//IL_046d: Expected O, but got Unknown
			//IL_055b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0580: Expected O, but got Unknown
			//IL_05ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d3: Expected O, but got Unknown
			//IL_0601: Unknown result type (might be due to invalid IL or missing references)
			//IL_0623: Expected O, but got Unknown
			LimitToVanillaPortals = plugin.ConfigEntry("1 - General", "Limit To Vanilla Portals", PortalRulesPlugin.Toggle.Off, "If on, normal portal handling is limited to vanilla wood and stone portal prefabs. PortalRules Admin Portal prefabs remain handled.", synchronizedSetting: true, 100, 500);
			EnablePortalMap = plugin.ConfigEntry("2 - Portal Map", "Enable Portal Map", PortalRulesPlugin.Toggle.On, "If on, entering a portal opens a portal target map.", synchronizedSetting: true, 400, 400);
			ToggleAccessiblePortalsKey = plugin.ConfigEntry<KeyboardShortcut>("2 - Portal Map", "Toggle Accessible Portal Pins Key", new KeyboardShortcut((KeyCode)112, Array.Empty<KeyCode>()), "Keyboard shortcut used while the large map is open to show or hide accessible portal pins.", synchronizedSetting: false, 300, 400);
			AutoCloseGraceSeconds = plugin.ConfigEntry("2 - Portal Map", "Auto Close Grace Seconds", 0.5f, new ConfigDescription("Seconds to wait after leaving the source portal area before closing the portal target map. Set to 0 to disable automatic closing.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 2f), Array.Empty<object>()), synchronizedSetting: false, 200, 400);
			PortalMapWheelZoomMultiplier = plugin.ConfigEntry("2 - Portal Map", "Portal Map Wheel Zoom Multiplier", 3, new ConfigDescription("Multiplier applied to mouse-wheel zoom only while the portal destination map is active. 1 uses Valheim's normal zoom rate.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 10), Array.Empty<object>()), synchronizedSetting: false, 100, 400);
			FavoritePortalListCollapsed = plugin.ConfigEntry("2 - Portal Map", "Favorite Portal List Collapsed", PortalRulesPlugin.Toggle.Off, "Stores whether the Favorite Portals list is collapsed.", synchronizedSetting: false, 50, 400, false);
			FavoritePortalListCollapsed.SettingChanged += delegate
			{
				PublicPortalMapController.Instance.RefreshFavoritePanelFromPreference();
			};
			ToggleAccessKey = plugin.ConfigEntry<KeyboardShortcut>("3 - Access Modes", "Portal Access Modifier Key", new KeyboardShortcut((KeyCode)304, Array.Empty<KeyCode>()), "Modifier key held while interacting with a portal to cycle its access mode.", synchronizedSetting: false, 600, 300);
			PublicAccessDurationSeconds = plugin.ConfigEntry("3 - Access Modes", "Public Access Duration Seconds", 900, new ConfigDescription("Seconds before a player-built Public portal returns to its authenticated Builder's Personal access. 0 disables automatic reversion.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 604800), Array.Empty<object>()), synchronizedSetting: true, 500, 300);
			PublicAccessDurationSeconds.SettingChanged += delegate
			{
				PublicPortalCatalog.RefreshTemporaryPublicConfiguration();
			};
			MaxInvitePortalsPerAccount = plugin.ConfigEntry("3 - Access Modes", "Max Invite Portals Per Account", 1, new ConfigDescription("Maximum player-built portals one authenticated Steam account may keep in Invite mode. -1 is unlimited. An effective value of 0 disables Invite mode and returns existing eligible Invite portals to their immutable Builder's Personal access.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(-1, 10000), Array.Empty<object>()), synchronizedSetting: true, 400, 300);
			InviteDepartureCooldownHours = plugin.ConfigEntry("3 - Access Modes", "Invite Departure Cooldown Hours", 1f, new ConfigDescription("Per-Steam-account, per-Invite-portal cooldown after using that portal as the source. 0 disables the departure cooldown.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 8760f), Array.Empty<object>()), synchronizedSetting: true, 300, 300);
			InviteArrivalCooldownHours = plugin.ConfigEntry("3 - Access Modes", "Invite Arrival Cooldown Hours", 1f, new ConfigDescription("Per-Steam-account, per-Invite-portal cooldown after using that portal as the destination. 0 disables the arrival cooldown.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 8760f), Array.Empty<object>()), synchronizedSetting: true, 200, 300);
			EventHandler eventHandler = delegate
			{
				PublicPortalCatalog.RefreshInviteCooldownConfiguration();
			};
			InviteDepartureCooldownHours.SettingChanged += eventHandler;
			InviteArrivalCooldownHours.SettingChanged += eventHandler;
			MaxClanPortalsPerClan = plugin.ConfigEntry("3 - Access Modes", "Max Clan Portals Per Clan", 5, new ConfigDescription("Maximum player-built portals that may be assigned to one Clan. -1 is unlimited and 0 disables entering Clan mode.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(-1, 10000), Array.Empty<object>()), synchronizedSetting: true, 100, 300);
			EnableAccountPortalLimit = plugin.ConfigEntry("4 - Account Portal Limit", "Enable Account Portal Limit", PortalRulesPlugin.Toggle.On, "If on, the server limits player-built portals by authenticated SteamID64, across all characters on that Steam account. If off, the account limit and every portal_limit override are bypassed; Invite and Clan limits remain active.", synchronizedSetting: true, 300, 200);
			MaxPortalsPerAccount = plugin.ConfigEntry("4 - Account Portal Limit", "Max Portals Per Account", 10, new ConfigDescription("Maximum counted portals an authenticated account may have in this world. -1 makes the global default unlimited while portal_limit overrides remain active; 0 blocks new counted portals.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(-1, 10000), Array.Empty<object>()), synchronizedSetting: true, 200, 200);
			CountedPortalPrefabs = plugin.ConfigEntry("4 - Account Portal Limit", "Counted Portal Prefabs", "portal_wood,portal,portal_stone", "Comma-separated prefab names counted by the account limit. Admin portal prefabs are always excluded.", synchronizedSetting: true, 100, 200);
			EventHandler eventHandler2 = delegate
			{
				PublicPortalServerPolicy.NotifyQuotaConfigurationChanged();
			};
			EnableAccountPortalLimit.SettingChanged += eventHandler2;
			MaxPortalsPerAccount.SettingChanged += eventHandler2;
			MaxInvitePortalsPerAccount.SettingChanged += eventHandler2;
			MaxClanPortalsPerClan.SettingChanged += eventHandler2;
			CountedPortalPrefabs.SettingChanged += eventHandler2;
			TravelCostScope = plugin.ConfigEntry("5 - Portal Travel Costs", "Travel Cost Scope", PublicPortalTravelCostScope.Off, "Off disables Coins costs. All charges every handled portal trip. AdminPortalTrips charges trips where either endpoint is an Admin Portal prefab. PersonalAndClanRoutesFree makes a trip free only when both endpoints are Personal or Clan. AllItemsSourceTrips charges only when the source portal allows every item.", synchronizedSetting: true, 400, 100);
			BaseCoinCost = plugin.ConfigEntry("5 - Portal Travel Costs", "Base Coin Cost", 10, new ConfigDescription("Coins charged for a paid portal trip before any distance surcharge.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 1000000), Array.Empty<object>()), synchronizedSetting: true, 300, 100);
			BaseFareIncludedDistanceMeters = plugin.ConfigEntry("5 - Portal Travel Costs", "Base Fare Included Distance Meters", 1000f, new ConfigDescription("XZ distance covered by the base fare before the per-kilometer surcharge begins.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1000000f), Array.Empty<object>()), synchronizedSetting: true, 200, 100);
			CoinsPerKilometer = plugin.ConfigEntry("5 - Portal Travel Costs", "Coins Per Kilometer", 5f, new ConfigDescription("Additional Coins per kilometer beyond the distance included in the base fare. The surcharge is rounded up.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1000000f), Array.Empty<object>()), synchronizedSetting: true, 100, 100);
		}
	}
	[HarmonyPatch]
	internal static class PublicPortalConnectedHud
	{
		[HarmonyPatch(typeof(Hud), "UpdateCrosshair")]
		private static class ConnectedTravelCostHoverPatch
		{
			private static void Postfix(Hud __instance, Player player)
			{
				if (!TryGetConnectedTravelInfo(player, out var travelCost, out var allowsAllItems) || !EnsureConnectedTravelBadge(__instance))
				{
					HideConnectedTravelBadge();
					return;
				}
				UpdateConnectedTravelBadge(travelCost, allowsAllItems);
				PositionConnectedTravelBadge(__instance);
			}
		}

		private static readonly Color UnaffordableTravelColor = new Color(1f, 0.42f, 0.32f);

		private static readonly Color AllItemsTravelColor = new Color(0.72f, 0.92f, 0.72f);

		private static Hud? ConnectedTravelHud;

		private static GameObject? ConnectedTravelBadge;

		private static Image? ConnectedTravelCoinIcon;

		private static TextMeshProUGUI? ConnectedTravelCostText;

		private static TextMeshProUGUI? ConnectedTravelAllItemsText;

		private static string ConnectedTravelLayoutText = "";

		private static Vector2 ConnectedTravelLayoutSize = new Vector2(float.NaN, float.NaN);

		private static float ConnectedTravelLayoutFontSize = float.NaN;

		internal static void Shutdown()
		{
			//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)
			if ((Object)(object)ConnectedTravelBadge != (Object)null)
			{
				Object.Destroy((Object)(object)ConnectedTravelBadge);
			}
			ConnectedTravelHud = null;
			ConnectedTravelBadge = null;
			ConnectedTravelCoinIcon = null;
			ConnectedTravelCostText = null;
			ConnectedTravelAllItemsText = null;
			ConnectedTravelLayoutText = "";
			ConnectedTravelLayoutSize = new Vector2(float.NaN, float.NaN);
			ConnectedTravelLayoutFontSize = float.NaN;
		}

		private static bool TryGetConnectedTravelInfo(Player player, out int travelCost, out bool allowsAllItems)
		{
			//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)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			travelCost = 0;
			allowsAllItems = false;
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			GameObject hoverObject = ((Humanoid)player).GetHoverObject();
			TeleportWorld val = (((Object)(object)hoverObject != (Object)null) ? hoverObject.GetComponentInParent<TeleportWorld>() : null);
			if ((Object)(object)val == (Object)null || !PublicPortalKinds.IsHandledPortal(val))
			{
				return false;
			}
			ZDO portalZdo = PublicPortalKinds.GetPortalZdo(val);
			if (portalZdo == null || (PublicPortalConfig.EnablePortalMap.Value.IsOn() && PublicPortalCatalog.GetEffectiveAccessMode(portalZdo) != PublicPortalAccessMode.Tagged) || !PublicPortalCatalog.TryGetClientEntry(portalZdo.m_uid, out var entry))
			{
				return false;
			}
			ZDOID connectionZDOID = portalZdo.GetConnectionZDOID((ConnectionType)1);
			if (((ZDOID)(ref connectionZDOID)).IsNone() || connectionZDOID == portalZdo.m_uid || !PublicPortalCatalog.TryGetClientEntry(connectionZDOID, out var entry2) || (PublicPortalConfig.EnablePortalMap.Value.IsOn() && entry2.AccessMode != PublicPortalAccessMode.Tagged) || !PublicPortalAccess.CanUsePortal(entry) || !PublicPortalAccess.CanUsePortal(entry2))
			{
				return false;
			}
			travelCost = PublicPortalTravelCost.CalculateCost(entry, entry2);
			allowsAllItems = val.m_allowAllItems;
			return (travelCost > 0) | allowsAllItems;
		}

		private static bool EnsureConnectedTravelBadge(Hud hud)
		{
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Expected O, but got Unknown
			//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_00fc: 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_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: 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)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0343: Unknown result type (might be due to invalid IL or missing references)
			//IL_0348: Unknown result type (might be due to invalid IL or missing references)
			//IL_0354: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_042d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0432: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)hud == (Object)null || (Object)(object)hud.m_hoverName == (Object)null)
			{
				return false;
			}
			if ((Object)(object)ConnectedTravelHud == (Object)(object)hud && (Object)(object)ConnectedTravelBadge != (Object)null && (Object)(object)ConnectedTravelCoinIcon != (Object)null && (Object)(object)ConnectedTravelCostText != (Object)null && (Object)(object)ConnectedTravelAllItemsText != (Object)null)
			{
				if ((Object)(object)ConnectedTravelCoinIcon.sprite == (Object)null)
				{
					ConnectedTravelCoinIcon.sprite = PublicPortalTravelCost.GetCoinIcon();
				}
				return true;
			}
			if ((Object)(object)ConnectedTravelBadge != (Object)null)
			{
				Object.Destroy((Object)(object)ConnectedTravelBadge);
			}
			Sprite coinIcon = PublicPortalTravelCost.GetCoinIcon();
			GameObject val = new GameObject("PortalRulesConnectedTravelInfo", new Type[1] { typeof(RectTransform) });
			val.layer = ((Component)hud.m_hoverName).gameObject.layer;
			val.transform.SetParent(((TMP_Text)hud.m_hoverName).transform, false);
			RectTransform val2 = (RectTransform)val.transform;
			val2.anchorMin = ((TMP_Text)hud.m_hoverName).rectTransform.pivot;
			val2.anchorMax = ((TMP_Text)hud.m_hoverName).rectTransform.pivot;
			val2.pivot = new Vector2(0f, 0.5f);
			val2.anchoredPosition = new Vector2(6f, 0f);
			val2.sizeDelta = new Vector2(0f, 22f);
			GameObject val3 = new GameObject("CoinsIcon", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			})
			{
				layer = val.layer
			};
			val3.transform.SetParent(val.transform, false);
			RectTransform val4 = (RectTransform)val3.transform;
			val4.anchorMin = new Vector2(0f, 0.5f);
			val4.anchorMax = new Vector2(0f, 0.5f);
			val4.pivot = new Vector2(0f, 0.5f);
			val4.anchoredPosition = Vector2.zero;
			val4.sizeDelta = new Vector2(20f, 20f);
			Image component = val3.GetComponent<Image>();
			component.sprite = coinIcon;
			component.preserveAspect = true;
			((Graphic)component).raycastTarget = false;
			GameObject val5 = new GameObject("Count", new Type[2]
			{
				typeof(RectTransform),
				typeof(TextMeshProUGUI)
			})
			{
				layer = val.layer
			};
			val5.transform.SetParent(val.transform, false);
			RectTransform val6 = (RectTransform)val5.transform;
			val6.anchorMin = Vector2.zero;
			val6.anchorMax = Vector2.one;
			val6.offsetMin = new Vector2(24f, 0f);
			val6.offsetMax = Vector2.zero;
			TextMeshProUGUI component2 = val5.GetComponent<TextMeshProUGUI>();
			((TMP_Text)component2).font = ((TMP_Text)hud.m_hoverName).font;
			((TMP_Text)component2).fontSharedMaterial = ((TMP_Text)hud.m_hoverName).fontSharedMaterial;
			((TMP_Text)component2).fontSize = Mathf.Max(14f, ((TMP_Text)hud.m_hoverName).fontSize * 0.75f);
			((TMP_Text)component2).fontStyle = (FontStyles)1;
			((TMP_Text)component2).alignment = (TextAlignmentOptions)513;
			((TMP_Text)component2).textWrappingMode = (TextWrappingModes)0;
			((TMP_Text)component2).overflowMode = (TextOverflowModes)0;
			((Graphic)component2).raycastTarget = false;
			GameObject val7 = new GameObject("AllItems", new Type[2]
			{
				typeof(RectTransform),
				typeof(TextMeshProUGUI)
			})
			{
				layer = val.layer
			};
			val7.transform.SetParent(val.transform, false);
			TextMeshProUGUI component3 = val7.GetComponent<TextMeshProUGUI>();
			((TMP_Text)component3).font = ((TMP_Text)hud.m_hoverName).font;
			((TMP_Text)component3).fontSharedMaterial = ((TMP_Text)hud.m_hoverName).fontSharedMaterial;
			((TMP_Text)component3).fontSize = Mathf.Max(14f, ((TMP_Text)hud.m_hoverName).fontSize * 0.75f);
			((TMP_Text)component3).fontStyle = (FontStyles)1;
			((TMP_Text)component3).alignment = (TextAlignmentOptions)513;
			((TMP_Text)component3).textWrappingMode = (TextWrappingModes)0;
			((TMP_Text)component3).overflowMode = (TextOverflowModes)0;
			((Graphic)component3).color = AllItemsTravelColor;
			((TMP_Text)component3).text = PortalRulesLocalization.Translate("$sighsorry_portalrules_all_items");
			((Graphic)component3).raycastTarget = false;
			val.SetActive(false);
			ConnectedTravelHud = hud;
			ConnectedTravelBadge = val;
			ConnectedTravelCoinIcon = component;
			ConnectedTravelCostText = component2;
			ConnectedTravelAllItemsText = component3;
			ConnectedTravelLayoutText = "";
			ConnectedTravelLayoutSize = new Vector2(float.NaN, float.NaN);
			ConnectedTravelLayoutFontSize = float.NaN;
			return true;
		}

		private static void UpdateConnectedTravelBadge(int travelCost, bool allowsAllItems)
		{
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ConnectedTravelBadge == (Object)null || (Object)(object)ConnectedTravelCoinIcon == (Object)null || (Object)(object)ConnectedTravelCostText == (Object)null || (Object)(object)ConnectedTravelAllItemsText == (Object)null)
			{
				return;
			}
			float num = 0f;
			bool flag = travelCost > 0;
			Sprite val = (flag ? (ConnectedTravelCoinIcon.sprite ?? PublicPortalTravelCost.GetCoinIcon()) : null);
			bool flag2 = (Object)(object)val != (Object)null;
			((Component)ConnectedTravelCoinIcon).gameObject.SetActive(flag2);
			if (flag2)
			{
				ConnectedTravelCoinIcon.sprite = val;
				SetConnectedTravelChildRect(((Graphic)ConnectedTravelCoinIcon).rectTransform, num, 20f);
				num += 24f;
			}
			((Component)ConnectedTravelCostText).gameObject.SetActive(flag);
			if (flag)
			{
				((TMP_Text)ConnectedTravelCostText).text = (flag2 ? PortalRulesLocalization.Translate("$sighsorry_portalrules_quantity", travelCost.ToString()) : PortalRulesLocalization.Translate("$sighsorry_portalrules_coins_quantity", travelCost.ToString()));
				((Graphic)ConnectedTravelCostText).color = ((PublicPortalTravelCost.GetLocalCoinCount() >= travelCost) ? Color.white : UnaffordableTravelColor);
				float num2 = Mathf.Ceil(((TMP_Text)ConnectedTravelCostText).preferredWidth) + 2f;
				SetConnectedTravelChildRect(((TMP_Text)ConnectedTravelCostText).rectTransform, num, num2);
				num += num2;
			}
			((Component)ConnectedTravelAllItemsText).gameObject.SetActive(allowsAllItems);
			if (allowsAllItems)
			{
				if (num > 0f)
				{
					num += 8f;
				}
				((TMP_Text)ConnectedTravelAllItemsText).text = (flag ? PortalRulesLocalization.Translate("$sighsorry_portalrules_all_items_bulleted") : PortalRulesLocalization.Translate("$sighsorry_portalrules_all_items"));
				float num3 = Mathf.Ceil(((TMP_Text)ConnectedTravelAllItemsText).preferredWidth) + 2f;
				SetConnectedTravelChildRect(((TMP_Text)ConnectedTravelAllItemsText).rectTransform, num, num3);
				num += num3;
			}
			((RectTransform)ConnectedTravelBadge.transform).sizeDelta = new Vector2(num, 22f);
			if (!ConnectedTravelBadge.activeSelf)
			{
				ConnectedTravelBadge.SetActive(true);
			}
		}

		private static void SetConnectedTravelChildRect(RectTransform rect, float x, float width)
		{
			//IL_000b: 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_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMin = new Vector2(0f, 0.5f);
			rect.anchorMax = new Vector2(0f, 0.5f);
			rect.pivot = new Vector2(0f, 0.5f);
			rect.anchoredPosition = new Vector2(x, 0f);
			rect.sizeDelta = new Vector2(width, 20f);
		}

		private static void PositionConnectedTravelBadge(Hud hud)
		{
			//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_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_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			//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_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: 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_0190: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ConnectedTravelBadge == (Object)null || (Object)(object)hud.m_hoverName == (Object)null)
			{
				return;
			}
			RectTransform rectTransform = ((TMP_Text)hud.m_hoverName).rectTransform;
			Rect rect = rectTransform.rect;
			Vector2 size = ((Rect)(ref rect)).size;
			string text = ((TMP_Text)hud.m_hoverName).text ?? "";
			float fontSize = ((TMP_Text)hud.m_hoverName).fontSize;
			if (string.Equals(ConnectedTravelLayoutText, text, StringComparison.Ordinal) && ConnectedTravelLayoutSize == size && ConnectedTravelLayoutFontSize.Equals(fontSize))
			{
				return;
			}
			ConnectedTravelLayoutText = text;
			ConnectedTravelLayoutSize = size;
			ConnectedTravelLayoutFontSize = fontSize;
			RectTransform val = (RectTransform)ConnectedTravelBadge.transform;
			try
			{
				((TMP_Text)hud.m_hoverName).ForceMeshUpdate(false, false);
				TMP_TextInfo textInfo = ((TMP_Text)hud.m_hoverName).textInfo;
				if (textInfo == null || textInfo.lineCount <= 0 || textInfo.lineInfo[0].characterCount <= 0)
				{
					SetConnectedTravelFallbackPosition(val);
					return;
				}
				TMP_LineInfo val2 = textInfo.lineInfo[0];
				float num = val2.lineExtents.max.x + 6f;
				float num2 = (val2.ascender + val2.descender) * 0.5f;
				if (float.IsNaN(num) || float.IsInfinity(num) || float.IsNaN(num2) || float.IsInfinity(num2))
				{
					SetConnectedTravelFallbackPosition(val);
					return;
				}
				val.anchorMin = rectTransform.pivot;
				val.anchorMax = rectTransform.pivot;
				val.pivot = new Vector2(0f, 0.5f);
				val.anchoredPosition = new Vector2(num, num2);
			}
			catch (Exception ex)
			{
				SetConnectedTravelFallbackPosition(val);
				PortalRulesPlugin.PortalRulesLogger.LogDebug((object)("Could not align the connected portal fare with the first hover line: " + ex.Message));
			}
		}

		private static void SetConnectedTravelFallbackPosition(RectTransform badgeRect)
		{
			//IL_000b: 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_0035: 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)
			badgeRect.anchorMin = new Vector2(0.5f, 0f);
			badgeRect.anchorMax = new Vector2(0.5f, 0f);
			badgeRect.pivot = new Vector2(0.5f, 1f);
			badgeRect.anchoredPosition = new Vector2(0f, -4f);
		}

		private static void HideConnectedTravelBadge()
		{
			if ((Object)(object)ConnectedTravelBadge != (Object)null && ConnectedTravelBadge.activeSelf)
			{
				ConnectedTravelBadge.SetActive(false);
			}
		}
	}
	internal enum PublicPortalAccessMode
	{
		Personal,
		Admin,
		Public,
		Clan,
		Tagged,
		Invite
	}
	internal enum PublicPortalTravelCostScope
	{
		Off,
		All,
		AdminPortalTrips,
		PersonalAndClanRoutesFree,
		AllItemsSourceTrips
	}
	internal enum RequiredGlobalKeyValidationFailure
	{
		None,
		TooLong,
		ControlCharacters,
		NumericKey,
		ReservedKey
	}
	internal readonly struct PortalOwner
	{
		public readonly string Id;

		public readonly string Name;

		public bool IsValid => !string.IsNullOrWhiteSpace(Id);

		public PortalOwner(string id, string name)
		{
			Id = PublicPortalData.NormalizeId(id);
			Name = name ?? "";
		}
	}
	internal readonly struct PortalBuilder
	{
		public readonly string AccountId;

		public readonly string Name;

		public readonly string PlatformId;

		public readonly long CharacterPlayerId;

		public readonly long BuildSequence;

		public bool IsValid => !string.IsNullOrWhiteSpace(AccountId);

		public PortalBuilder(string accountId, string name)
			: this(accountId, name, accountId, 0L, 0L)
		{
		}

		public PortalBuilder(string accountId, string name, string platformId, long characterPlayerId, long buildSequence)
		{
			AccountId = PublicPortalData.NormalizeId(accountId);
			Name = name ?? "";
			PlatformId = PublicPortalData.NormalizeId(platformId);
			CharacterPlayerId = characterPlayerId;
			BuildSequence = Math.Max(0L, buildSequence);
		}

		public PortalBuilder WithBuildSequence(long buildSequence)
		{
			return new PortalBuilder(AccountId, Name, PlatformId, CharacterPlayerId, buildSequence);
		}
	}
	internal static class PublicPortalData
	{
		private static readonly FieldRef<ZNet, Platform> SteamPlatform = AccessTools.FieldRefAccess<ZNet, Platform>("m_steamPlatform");

		private static string _serverAssignedOwnerId = "";

		private static bool _serverAssignedIsAdmin;

		internal const int ClanAccessAuthorityVersion = 3;

		internal const int RequiredGlobalKeyAuthorityVersion = 4;

		internal const int TemporaryPublicAuthorityVersion = 5;

		internal const int InviteAccessAuthorityVersion = 6;

		internal const int CurrentAccessAuthorityVersion = 6;

		internal const int CurrentBuilderAuthorityVersion = 2;

		internal const int MaximumRequiredGlobalKeyLength = 128;

		internal const long MaximumPublicExpiresAtUtcSeconds = 253402300799L;

		internal const float MaximumTeleportSourceDistance = 15f;

		public const string AccessModeKey = "PortalRules AccessMode";

		public const string OwnerIdKey = "PortalRules OwnerId";

		public const string OwnerNameKey = "PortalRules OwnerName";

		public const string AuthorizedClanIdKey = "PortalRules AuthorizedClanId";

		public const string AuthorityVersionKey = "PortalRules AuthorityVersion";

		public const string BuilderAccountIdKey = "PortalRules BuilderAccountId";

		public const string BuilderNameKey = "PortalRules BuilderName";

		public const string BuilderPlatformIdKey = "PortalRules BuilderPlatformId";

		public const string BuilderCharacterPlayerIdKey = "PortalRules BuilderPlayerId";

		public const string PortalBuildSequenceKey = "PortalRules BuildSequence";

		public const string BuilderAuthorityVersionKey = "PortalRules BuilderAuthorityVersion";

		public const string AuthorizedPrefabHashKey = "PortalRules AuthorizedPrefabHash";

		public const string PublicExpiresAtUtcSecondsKey = "PortalRules PublicExpiresAtUtc";

		public const string FavoriteIdKey = "PortalRules FavoriteId";

		public const string RequiredGlobalKeyKey = "PortalRules RequiredGlobalKey";

		internal const int MaximumFavoriteCount = 10;

		public const string ChangeAccessModeRpc = "sighsorry.PortalRules.ChangeAccessMode.v4";

		public const string ChangeAccessModeResultRpc = "sighsorry.PortalRules.ChangeAccessModeResult.v5";

		public const string ChangeAdminPortalTagRpc = "sighsorry.PortalRules.ChangeAdminPortalTag.v1";

		public const string ChangeAdminPortalRequiredGlobalKeyRpc = "sighsorry.PortalRules.ChangeAdminPortalRequiredGlobalKey.v1";

		public const string RemoveAdminPortalRpc = "sighsorry.PortalRules.RemoveAdminPortal.v1";

		public const string FavoritesKey = "PortalRules Favorites v3";

		public static string ServerAssignedOwnerId => _serverAssignedOwnerId;

		public static bool ServerAssignedIsAdmin => _serverAssignedIsAdmin;

		public static PublicPortalAccessMode GetAccessMode(ZDO zdo)
		{
			int num = zdo.GetInt("PortalRules AccessMode", 0);
			if (!Enum.IsDefined(typeof(PublicPortalAccessMode), num) || (num == 5 && zdo.GetInt("PortalRules AuthorityVersion", 0) < 6))
			{
				return PublicPortalAccessMode.Personal;
			}
			return (PublicPortalAccessMode)num;
		}

		public static PortalOwner GetOwner(ZDO zdo)
		{
			return new PortalOwner(zdo.GetString("PortalRules OwnerId", ""), zdo.GetString("PortalRules OwnerName", ""));
		}

		public static PortalBuilder GetBuilder(ZDO zdo)
		{
			return new PortalBuilder(zdo.GetString("PortalRules BuilderAccountId", ""), zdo.GetString("PortalRules BuilderName", ""), zdo.GetString("PortalRules BuilderPlatformId", ""), zdo.GetLong("PortalRules BuilderPlayerId", 0L), zdo.GetLong("PortalRules BuildSequence", 0L));
		}

		public static string GetAuthorizedClanId(ZDO zdo)
		{
			return (zdo.GetString("PortalRules AuthorizedClanId", "") ?? "").Trim();
		}

		public static string GetRequiredGlobalKey(ZDO zdo)
		{
			return (zdo.GetString("PortalRules RequiredGlobalKey", "") ?? "").Trim();
		}

		public static long GetPublicExpiresAtUtcSeconds(ZDO zdo)
		{
			return NormalizePublicExpiresAtUtcSeconds(zdo.GetLong("PortalRules PublicExpiresAtUtc", 0L));
		}

		public static void SetAccessMode(ZDO zdo, PublicPortalAccessMode mode, PortalOwner owner)
		{
			zdo.Set("PortalRules AccessMode", (int)mode);
			zdo.Set("PortalRules OwnerId", owner.Id);
			zdo.Set("PortalRules OwnerName", owner.Name);
		}

		public static void SetAuthorizedClanId(ZDO zdo, string authorizedClanId)
		{
			zdo.Set("PortalRules AuthorizedClanId", (authorizedClanId ?? "").Trim());
		}

		public static void SetRequiredGlobalKey(ZDO zdo, string requiredGlobalKey)
		{
			zdo.Set("PortalRules RequiredGlobalKey", (requiredGlobalKey ?? "").Trim());
		}

		public static void SetPublicExpiresAtUtcSeconds(ZDO zdo, long publicExpiresAtUtcSeconds)
		{
			zdo.Set("PortalRules PublicExpiresAtUtc", NormalizePublicExpiresAtUtcSeconds(publicExpiresAtUtcSeconds));
		}

		internal static long NormalizePublicExpiresAtUtcSeconds(long value)
		{
			if (value <= 0 || value > 253402300799L)
			{
				return 0L;
			}
			return value;
		}

		internal static bool TryNormalizeRequiredGlobalKey(string? value, out string normalized, out RequiredGlobalKeyValidationFailure failure)
		{
			//IL_008f: 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_00a6: Invalid comparison between Unknown and I4
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Invalid comparison between Unknown and I4
			normalized = (value ?? "").Trim();
			failure = RequiredGlobalKeyValidationFailure.None;
			if (normalized.Length == 0)
			{
				return true;
			}
			if (normalized.Length > 128)
			{
				failure = RequiredGlobalKeyValidationFailure.TooLong;
				return false;
			}
			string text = normalized;
			for (int i = 0; i < text.Length; i++)
			{
				if (char.IsControl(text[i]))
				{
					failure = RequiredGlobalKeyValidationFailure.ControlCharacters;
					return false;
				}
			}
			GlobalKeys val = default(GlobalKeys);
			string keyValue = ZoneSystem.GetKeyValue(normalized, ref text, ref val);
			if (long.TryParse(keyValue, NumberStyles.Integer, CultureInfo.InvariantCulture, out var _))
			{
				failure = RequiredGlobalKeyValidationFailure.NumericKey;
				return false;
			}
			GlobalKeys result2;
			bool flag = Enum.TryParse<GlobalKeys>(keyValue, ignoreCase: true, out result2) && Enum.IsDefined(typeof(GlobalKeys), result2);
			if (flag)
			{
				bool flag2 = (((int)result2 == 32 || (int)result2 == 43) ? true : false);
				flag = flag2;
			}
			if (flag)
			{
				failure = RequiredGlobalKeyValidationFailure.ReservedKey;
				return false;
			}
			return true;
		}

		public static void SetBuilder(ZDO zdo, PortalBuilder builder, int prefabHash)
		{
			zdo.Set("PortalRules BuilderAccountId", builder.AccountId);
			zdo.Set("PortalRules BuilderName", builder.Name);
			zdo.Set("PortalRules BuilderPlatformId", builder.PlatformId);
			zdo.Set("PortalRules BuilderPlayerId", builder.CharacterPlayerId);
			zdo.Set("PortalRules BuildSequence", builder.BuildSequence);
			zdo.Set("PortalRules AuthorizedPrefabHash", prefabHash);
		}

		public static PortalOwner LocalOwner()
		{
			string text = _serverAssignedOwnerId;
			if (string.IsNullOrWhiteSpace(text) && TryGetLocalSteamId64(out string steamId))
			{
				text = steamId;
			}
			string name = (((Object)(object)Player.m_localPlayer != (Object)null) ? ((Character)Player.m_localPlayer).GetHoverName() : "");
			return new PortalOwner(text, name);
		}

		public static void SetServerAssignedOwnerId(string ownerId)
		{
			_serverAssignedOwnerId = NormalizeId(ownerId);
		}

		public static void SetServerAssignedIsAdmin(bool isAdmin)
		{
			_serverAssignedIsAdmin = isAdmin;
		}

		public static bool TryGetPeerOwner(ZNetPeer? peer, out PortalOwner owner)
		{
			owner = new PortalOwner("", "");
			if (!TryGetPeerSteamId64(peer, out string steamId))
			{
				return false;
			}
			owner = new PortalOwner(steamId, peer?.m_playerName ?? "");
			return owner.IsValid;
		}

		internal unsafe static bool TryGetPeerSteamId64(ZNetPeer? peer, out string steamId)
		{
			//IL_0007: 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)
			steamId = "";
			if ((int)ZNet.m_onlineBackend != 0 || (Object)(object)ZNet.instance == (Object)null || peer?.m_socket == null)
			{
				return false;
			}
			string hostName = peer.m_socket.GetHostName();
			if (string.IsNullOrWhiteSpace(hostName))
			{
				return false;
			}
			PlatformUserID val = default(PlatformUserID);
			((PlatformUserID)(ref val))..ctor(SteamPlatform.Invoke(ZNet.instance), hostName);
			return TryNormalizeSteamId64(((object)(*(PlatformUserID*)(&val))/*cast due to .constrained prefix*/).ToString(), out steamId);
		}

		internal static bool TryGetLocalSteamId64(out string steamId)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			steamId = "";
			if ((int)ZNet.m_onlineBackend != 0)
			{
				return false;
			}
			try
			{
				if (TryNormalizeSteamId64(((object)Unsafe.As<PlatformUserID, PlatformUserID>(ref UserInfo.GetLocalUser().UserId)/*cast due to .constrained prefix*/).ToString(), out steamId))
				{
					return true;
				}
			}
			catch (Exception)
			{
			}
			IDistributionPlatform distributionPlatform = PlatformManager.DistributionPlatform;
			if (((distributionPlatform != null) ? distributionPlatform.LocalUser : null) != null)
			{
				return TryNormalizeSteamId64(((object)((IUser)distributionPlatform.LocalUser).PlatformUserID/*cast due to .constrained prefix*/).ToString(), out steamId);
			}
			return false;
		}

		internal static bool TryGetAuthenticatedPeerPlayerId(ZNetPeer? peer, out long playerId)
		{
			ZDO character;
			return TryGetAuthenticatedPeerCharacter(peer, out character, out playerId);
		}

		public static bool IsPeerAdmin(ZNet znet, ZNetPeer peer)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			if ((int)ZNet.m_onlineBackend == 0 && (Object)(object)znet != (Object)null && peer?.m_socket != null)
			{
				return znet.IsAdmin(peer.m_socket.GetHostName());
			}
			return false;
		}

		internal static ZNetPeer? FindPeer(ZNet? znet, ZRpc? rpc)
		{
			if ((Object)(object)znet == (Object)null || rpc == null)
			{
				return null;
			}
			foreach (ZNetPeer peer in znet.GetPeers())
			{
				if (peer != null && peer.m_rpc == rpc)
				{
					return peer;
				}
			}
			return null;
		}

		internal static bool TryGetAuthenticatedPeerCharacterPosition(ZNetPeer? peer, out Vector3 position)
		{
			//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_002c: 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_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: 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_00af: Unknown result type (might be due to invalid IL or missing references)
			position = Vector3.zero;
			if ((Object)(object)ZNetScene.instance == (Object)null || !TryGetAuthenticatedPeerCharacter(peer, out ZDO character, out long playerId))
			{
				return false;
			}
			GameObject val = ZNetScene.instance.FindInstance(peer.m_characterID);
			Player val2 = (((Object)(object)val != (Object)null) ? val.GetComponent<Player>() : null);
			ZNetView val3 = (((Object)(object)val != (Object)null) ? val.GetComponent<ZNetView>() : null);
			if ((Object)(object)val2 == (Object)null || (Object)(object)val3 == (Object)null || !val3.IsValid() || val3.GetZDO() != character || ((Character)val2).GetZDOID() != peer.m_characterID || val2.GetPlayerID() != playerId)
			{
				return false;
			}
			position = character.GetPosition();
			return IsFinite(position);
		}

		private static bool TryGetAuthenticatedPeerCharacter(ZNetPeer? peer, out ZDO character, out long playerId)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			character = null;
			playerId = 0L;
			if (peer == null || !peer.IsReady() || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || ZDOMan.instance == null || ((ZDOID)(ref peer.m_characterID)).IsNone() || ((ZDOID)(ref peer.m_characterID)).UserID != peer.m_uid)
			{
				return false;
			}
			ZDO zDO = ZDOMan.instance.GetZDO(peer.m_characterID);
			if (zDO == null || !zDO.IsValid() || zDO.GetOwner() != peer.m_uid)
			{
				return false;
			}
			if ((Object)(object)ZNetScene.instance != (Object)null)
			{
				GameObject prefab = ZNetScene.instance.GetPrefab(zDO.GetPrefab());
				if ((Object)(object)prefab == (Object)null || (Object)(object)prefab.GetComponent<Player>() == (Object)null)
				{
					return false;
				}
			}
			long num = zDO.GetLong(ZDOVars.s_playerID, 0L);
			if (num == 0L)
			{
				return false;
			}
			character = zDO;
			playerId = num;
			return true;
		}

		public static bool IsLocalOwner(PortalOwner owner)
		{
			if (owner.IsValid)
			{
				return string.Equals(owner.Id, LocalOwner().Id, StringComparison.Ordinal);
			}
			return false;
		}

		public static string NormalizeId(string id)
		{
			id = (id ?? "").Trim();
			if (!id.StartsWith("Steam_", StringComparison.Ordinal))
			{
				return id;
			}
			return id.Substring("Steam_".Length);
		}

		internal static bool TryNormalizeSteamId64(string? value, out string steamId)
		{
			steamId = "";
			string text = (value ?? "").Trim();
			if (text.StartsWith("Steam_", StringComparison.OrdinalIgnoreCase))
			{
				text = text.Substring("Steam_".Length);
			}
			if (text.Length != 17 || !ulong.TryParse(text, NumberStyles.None, CultureInfo.InvariantCulture, out var result) || result == 0L)
			{
				return false;
			}
			steamId = result.ToString(CultureInfo.InvariantCulture);
			return string.Equals(text, steamId, StringComparison.Ordinal);
		}

		public static bool TryNormalizeFavoriteId(string? favoriteId, out string normalizedFavoriteId)
		{
			normalizedFavoriteId = "";
			if (!Guid.TryParseExact((favoriteId ?? "").Trim(), "N", out var result) || result == Guid.Empty)
			{
				return false;
			}
			normalizedFavoriteId = result.ToString("N");
			return true;
		}

		public static void SetFavoriteId(ZDO zdo, string favoriteId)
		{
			if (zdo != null && TryNormalizeFavoriteId(favoriteId, out string normalizedFavoriteId))
			{
				zdo.Set("PortalRules FavoriteId", normalizedFavoriteId);
			}
		}

		private static bool IsFinite(Vector3 value)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//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)
			if (!float.IsNaN(value.x) && !float.IsInfinity(value.x) && !float.IsNaN(value.y) && !float.IsInfinity(value.y) && !float.IsNaN(value.z))
			{
				return !float.IsInfinity(value.z);
			}
			return false;
		}

		public static List<string> ReadFavorites()
		{
			if ((Object)(object)Player.m_localPlayer == (Object)null || !Player.m_localPlayer.m_customData.TryGetValue("PortalRules Favorites v3", out var value) || string.IsNullOrWhiteSpace(value))
			{
				return new List<string>();
			}
			List<string> list = new List<string>(10);
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			string[] array = value.Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				if (TryNormalizeFavoriteId(array[i], out string normalizedFavoriteId) && hashSet.Add(normalizedFavoriteId))
				{
					list.Add(normalizedFavoriteId);
					if (list.Count >= 10)
					{
						break;
					}
				}
			}
			return list;
		}

		public static void WriteFavorites(IEnumerable<string> favorites)
		{
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				return;
			}
			List<string> list = new List<string>(10);
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			foreach (string favorite in favorites)
			{
				if (TryNormalizeFavoriteId(favorite, out string normalizedFavoriteId) && hashSet.Add(normalizedFavoriteId))
				{
					list.Add(normalizedFavoriteId);
					if (list.Count >= 10)
					{
						break;
					}
				}
			}
			string value = string.Join(",", list);
			if (string.IsNullOrWhiteSpace(value))
			{
				Player.m_localPlayer.m_customData.Remove("PortalRules Favorites v3");
			}
			else
			{
				Player.m_localPlayer.m_customData["PortalRules Favorites v3"] = value;
			}
		}
	}
	internal readonly struct PublicPortalCatalogEntry
	{
		public readonly ZDOID Id;

		public readonly string FavoriteId;

		public readonly int PrefabHash;

		public readonly bool AllowsAllItems;

		public readonly Vector3 Position;

		public readonly Quaternion Rotation;

		public readonly string Tag;

		public readonly PublicPortalAccessMode AccessMode;

		public readonly PortalOwner Owner;

		public readonly int MyPortalOrdinal;

		public readonly int MyPortalLimit;

		public readonly int ModeOrdinal;

		public readonly int ModeCurrent;

		public readonly int ModeLimit;

		public readonly long InviteDepartureCooldownUntilUtc;

		public readonly long InviteArrivalCooldownUntilUtc;

		public PublicPortalCatalogEntry(ZDOID id, string favoriteId, int prefabHash, bool allowsAllItems, Vector3 position, Quaternion rotation, string tag, PublicPortalAccessMode accessMode, PortalOwner owner, int myPortalOrdinal = 0, int myPortalLimit = 0, int modeOrdinal = 0, int modeCurrent = 0, int modeLimit = 0, long inviteDepartureCooldownUntilUtc = 0L, long inviteArrivalCooldownUntilUtc = 0L)
		{
			//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_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			Id = id;
			FavoriteId = (PublicPortalData.TryNormalizeFavoriteId(favoriteId, out string normalizedFavoriteId) ? normalizedFavoriteId : "");
			PrefabHash = prefabHash;
			AllowsAllItems = allowsAllItems;
			Position = position;
			Rotation = rotation;
			Tag = tag ?? "";
			AccessMode = accessMode;
			Owner = owner;
			MyPortalOrdinal = Math.Max(0, myPortalOrdinal);
			MyPortalLimit = Math.Max(-1, myPortalLimit);
			ModeOrdinal = Math.Max(0, modeOrdinal);
			ModeCurrent = Math.Max(0, modeCurrent);
			ModeLimit = Math.Max(-1, modeLimit);
			InviteDepartureCooldownUntilUtc = Math.Max(0L, inviteDepartureCooldownUntilUtc);
			InviteArrivalCooldownUntilUtc = Math.Max(0L, inviteArrivalCooldownUntilUtc);
		}

		public bool HasSameContent(PublicPortalCatalogEntry other)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: 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_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			if (Id == other.Id && string.Equals(FavoriteId, other.FavoriteId, StringComparison.Ordinal) && PrefabHash == other.PrefabHash && AllowsAllItems == other.AllowsAllItems && Position == other.Position && Rotation == other.Rotation && string.Equals(Tag, other.Tag, StringComparison.Ordinal) && AccessMode == other.AccessMode && string.Equals(Owner.Id, other.Owner.Id, StringComparison.Ordinal) && string.Equals(Owner.Name, other.Owner.Name, StringComparison.Ordinal) && MyPortalOrdinal == other.MyPortalOrdinal && MyPortalLimit == other.MyPortalLimit && ModeOrdinal == other.ModeOrdinal && ModeCurrent == other.ModeCurrent && ModeLimit == other.ModeLimit && InviteDepartureCooldownUntilUtc == other.InviteDepartureCooldownUntilUtc)
			{
				return InviteArrivalCooldownUntilUtc == other.InviteArrivalCooldownUntilUtc;
			}
			return false;
		}

		public PublicPortalCatalogEntry WithDisplayMetadata(int myPortalOrdinal, int myPortalLimit, int modeOrdinal, int modeCurrent, int modeLimit, long inviteDepartureCooldownUntilUtc = 0L, long inviteArrivalCooldownUntilUtc = 0L)
		{
			//IL_0001: 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)
			return new PublicPortalCatalogEntry(Id, FavoriteId, PrefabHash, AllowsAllItems, Position, Rotation, Tag, AccessMode, Owner, myPortalOrdinal, myPortalLimit, modeOrdinal, modeCurrent, modeLimit, inviteDepartureCooldownUntilUtc, inviteArrivalCooldownUntilUtc);
		}
	}
	internal readonly struct LocalPortalPlacementState
	{
		public readonly PortalBuilder PreviousBuilder;

		public readonly HashSet<ZDOID>? PreviousPendingPortalIds;

		public LocalPortalPlacementState(PortalBuilder previousBuilder, HashSet<ZDOID>? previousPendingPortalIds)
		{
			PreviousBuilder = previousBuilder;
			PreviousPendingPortalIds = previousPendingPortalIds;
		}
	}
	internal static class PublicPortalCatalog
	{
		private readonly struct ServerPortalAuthority
		{
			public readonly PublicPortalAccessMode AccessMode;

			public readonly PortalOwner Owner;

			public readonly string AuthorizedClanId;

			public readonly PortalBuilder Builder;

			public readonly int PrefabHash;

			public readonly string FavoriteId;

			public readonly string RequiredGlobalKey;

			public readonly long PublicExpiresAtUtcSeconds;

			public readonly bool RequiredGlobalKeyIsValid;

			public ServerPortalAuthority(PublicPortalAccessMode accessMode, PortalOwner owner, string authorizedClanId, PortalBuilder builder, int prefabHash, string favoriteId, string requiredGlobalKey, long publicExpiresAtUtcSeconds)
			{
				AccessMode = accessMode;
				Owner = owner;
				AuthorizedClanId = authorizedClanId ?? "";
				Builder = builder;
				PrefabHash = prefabHash;
				FavoriteId = favoriteId ?? "";
				RequiredGlobalKeyIsValid = PublicPortalData.TryNormalizeRequiredGlobalKey(requiredGlobalKey, out string normalized, out RequiredGlobalKeyValidationFailure _);
				RequiredGlobalKey = (RequiredGlobalKeyIsValid ? normalized : (requiredGlobalKey ?? "").Trim());
				PublicExpiresAtUtcSeconds = ((accessMode == PublicPortalAccessMode.Public && builder.IsValid && !PublicPortalKinds.IsAdminPortalPrefab(prefabHash)) ? PublicPortalData.NormalizePublicExpiresAtUtcSeconds(publicExpiresAtUtcSeconds) : 0);
			}
		}

		private readonly struct AdminPortalTagAuthority
		{
			public readonly string Tag;

			public AdminPortalTagAuthority(string tag)
			{
				Tag = tag ?? "";
			}
		}

		private sealed class RecipientContext
		{
			public readonly string OwnerId;

			public readonly bool IsAdmin;

			public readonly PortalClanMembership ClanMembership;

			public readonly ZNetPeer? Peer;

			public readonly Dictionary<string, RequiredGlobalKeyQueryResult> RequiredGlobalKeyResults = new Dictionary<string, RequiredGlobalKeyQueryResult>(StringComparer.Ordinal);

			public RecipientContext(string ownerId, bool isAdmin, PortalClanMembership clanMembership, ZNetPeer? peer)
			{
				OwnerId = ownerId ?? "";
				IsAdmin = isAdmin;
				ClanMembership = clanMembership;
				Peer = peer;
			}
		}

		private readonly struct SentViewState
		{
			public readonly int Revision;

			public readonly string RecipientOwnerId;

			public readonly bool IsAdmin;

			public readonly ulong RecipientViewFingerprint;

			public readonly long ViewToken;

			public readonly bool Acknowledged;

			public readonly float LastSentAt;

			public SentViewState(int revision, string recipientOwnerId, bool isAdmin, ulong recipientViewFingerprint, long viewToken, bool acknowledged, float lastSentAt)
			{
				Revision = revision;
				RecipientOwnerId = recipientOwnerId;
				IsAdmin = isAdmin;
				RecipientViewFingerprint = recipientViewFingerprint;
				ViewToken = viewToken;
				Acknowledged = acknowledged;
				LastSentAt = lastSentAt;
			}

			public bool MatchesView(int revision, string recipientOwnerId, bool isAdmin, ulong recipientViewFingerprint)
			{
				if (MatchesRecipient(revision, recipientOwnerId, isAdmin))
				{
					return RecipientViewFingerprint == recipientViewFingerprint;
				}
				return false;
			}

			public bool MatchesRecipient(int revision, string recipientOwnerId, bool isAdmin)
			{
				if (Revision == revision && IsAdmin == isAdmin)
				{
					return string.Equals(RecipientOwnerId, recipientOwnerId, StringComparison.Ordinal);
				}
				return false;
			}

			public SentViewState WithAcknowledgement()
			{
				return new SentViewState(Revision, RecipientOwnerId, IsAdmin, RecipientViewFingerprint, ViewToken, acknowledged: true, LastSentAt);
			}
		}

		internal sealed class PortalSyncContext
		{
			public readonly ZNetPeer? Peer;

			public readonly HashSet<ZDOID> CreatedIds = new HashSet<ZDOID>();

			public PortalSyncContext(ZNetPeer? peer)
			{
				Peer = peer;
			}
		}

		private sealed class PendingSnapshot
		{
			public readonly int Revision;

			public readonly long ViewToken;

			public readonly int ChunkCount;

			public readonly int TotalCount;

			public readonly string RecipientOwnerId;

			public readonly bool RecipientIsAdmin;

			public readonly long ServerUtcAtSend;

			public readonly long FirstChunkReceivedTimestamp;

			public readonly List<PublicPortalCatalogEntry> Entries;

			public readonly HashSet<string> FavoriteIds = new HashSet<string>(StringComparer.Ordinal);

			public int NextChunk;

			public PendingSnapshot(int revision, long viewToken, int chunkCount, int totalCount, string recipientOwnerId, bool recipientIsAdmin, long serverUtcAtSend)
			{
				Revision = revision;
				ViewToken = viewToken;
				ChunkCount = chunkCount;
				TotalCount = totalCount;
				RecipientOwnerId = recipientOwnerId;
				RecipientIsAdmin = recipientIsAdmin;
				ServerUtcAtSend = serverUtcAtSend;
				FirstChunkReceivedTimestamp = Stopwatch.GetTimestamp();
				Entries = new List<PublicPortalCatalogEntry>(totalCount);
			}
		}

		private const byte FormatVersion = 7;

		private const int MaximumCatalogEntries = 100000;

		private const int MaximumEntriesPerChunk = 96;

		private const int MaximumChunkCount = 1042;

		private const int MaximumTagLength = 256;

		private const int MaximumOwnerIdLength = 128;

		private const int MaximumOwnerNameLength = 128;

		private const int MaximumClanIdLength = 128;

		private const int MaximumFavoriteIdLength = 32;

		private const float MaximumAdminPortalPlacementDistance = 15f;

		private const float MaximumPortalCoordinateMagnitude = 1000000f;

		private const double MinimumQuaternionSqrMagnitude = 0.25;

		private const double MaximumQuaternionSqrMagnitude = 4.0;

		private const float ServerRefreshSeconds = 5f;

		private const float ClientRequestCooldownSeconds = 0.5f;

		private const float ServerRequestCooldownSeconds = 30f;

		private const float SnapshotRetrySeconds = 30f;

		private const string RequestCatalogRpc = "sighsorry.PortalRules.CatalogRequest.v7";

		private const string ReceiveCatalogRpc = "sighsorry.PortalRules.CatalogSnapshot.v7";

		private static readonly List<PublicPortalCatalogEntry> ServerEntries = new List<PublicPortalCatalogEntry>();

		private static readonly List<PublicPortalCatalogEntry> ClientEntries = new List<PublicPortalCatalogEntry>();

		private static readonly Dictionary<ZDOID, PublicPortalCatalogEntry> ClientIndex = new Dictionary<ZDOID, PublicPortalCatalogEntry>();

		private static readonly Dictionary<ZDOID, ServerPortalAuthority> ServerAuthority = new Dictionary<ZDOID, ServerPortalAuthority>();

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

		private static readonly Dictionary<ZDOID, AdminPortalTagAuthority> AdminPortalTags = new Dictionary<ZDOID, AdminPortalTagAuthority>();

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

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

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

		private static readonly Dictionary<ZRpc, float> LastServerRequestAt = new Dictionary<ZRpc, float>();

		private static readonly Dictionary<ZRpc, SentViewState> LastSentViews = new Dictionary<ZRpc, SentViewState>();

		private static Game? _registeredGame;

		private static Game? _serverLoopGame;

		private static ZNet? _sessionZNet;

		private static int _serverRevision;

		private static int _clientRevision = -1;

		private static long _clientViewToken;

		private static long _nextViewToken;

		private static float _lastClientRequestAt = -100f;

		private static float _nextIdentityReconcileAt = -100f;

		private static bool _authorityBackfilled;

		private static bool _hasSnapshot;

		private static bool _worldLoaded;

		private static bool _serverCatalogDirty;

		private static bool _serverDirtyFlushScheduled;

		private static bool _localRecipientViewInitialized;

		private static string _localRecipientOwnerId = "";

		private static bool _localRecipientIsAdmin;

		private static ulong _localRecipientViewFingerprint;

		private static long _sessionGeneration;

		private static long _nextBuildSequence;

		private static long _clientServerUtcAtSync;

		private static long _clientServerClockTimestamp;

		[ThreadStatic]
		private static PortalSyncContext? _activePortalSync;

		[ThreadStatic]
		private static PortalBuilder _activeLocalPlacementBuilder;

		[ThreadStatic]
		private static HashSet<ZDOID>? _pendingLocalPlacementPortalIds;

		private static PendingSnapshot? _pendingSnapshot;

		public static IReadOnlyList<PublicPortalCatalogEntry> Entries => ClientEntries;

		public static bool HasSnapshot => _hasSnapshot;

		internal static bool IsServerReady
		{
			get
			{
				if (_worldLoaded && _authorityBackfilled && _hasSnapshot && (Object)(object)ZNet.instance != (Object)null)
				{
					return ZNet.instance.IsServer();
				}
				return false;
			}
		}

		public static event Action? Updated;

		private static void WriteCatalogEntry(ZPackage package, PublicPortalCatalogEntry entry)
		{
			//IL_0002: 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_003e: Unknown result type (might be due to invalid IL or missing references)
			package.Write(entry.Id);
			package.Write(entry.FavoriteId);
			package.Write(entry.PrefabHash);
			package.Write(entry.AllowsAllItems);
			package.Write(entry.Position);
			package.Write(entry.Rotation);
			package.Write(entry.Tag);
			package.Write((int)entry.AccessMode);
			package.Write(entry.Owner.Id);
			package.Write(entry.Owner.Name);
			package.Write(entry.MyPortalOrdinal);
			package.Write(entry.MyPortalLimit);
			package.Write(entry.ModeOrdinal);
			package.Write(entry.ModeCurrent);
			package.Write(entry.ModeLimit);
			package.Write(entry.InviteDepartureCooldownUntilUtc);
			package.Write(entry.InviteArrivalCooldownUntilUtc);
		}

		private static bool TryReadCatalogEntry(ZPackage package, HashSet<string> favoriteIds, out PublicPortalCatalogEntry entry)
		{
			//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_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			ZDOID id = package.ReadZDOID();
			string text = package.ReadString();
			int prefabHash = package.ReadInt();
			bool allowsAllItems = package.ReadBool();
			Vector3 val = package.ReadVector3();
			Quaternion val2 = package.ReadQuaternion();
			string text2 = package.ReadString();
			int num = package.ReadInt();
			string text3 = package.ReadString();
			string text4 = package.ReadString();
			int num2 = package.ReadInt();
			int num3 = package.ReadInt();
			int num4 = package.ReadInt();
			int num5 = package.ReadInt();
			int num6 = package.ReadInt();
			long num7 = package.ReadLong();
			long num8 = package.ReadLong();
			string normalizedFavoriteId = "";
			bool flag = text.Length <= 32 && PublicPortalData.TryNormalizeFavoriteId(text, out normalizedFavoriteId);
			bool num9 = num == 5 || num == 3;
			bool flag2 = num2 >= 0 && num2 <= 100000 && num3 >= -1 && num3 <= 10000 && (num2 != 0 || num3 == 0);
			bool flag3 = ((!num9) ? (num4 == 0 && num5 == 0 && num6 == 0) : (num4 > 0 && num4 <= 100000 && num5 >= num4 && num5 <= 100000 && num6 >= -1 && num6 <= 10000));
			bool flag4 = num7 >= 0 && num7 <= 253402300799L && num8 >= 0 && num8 <= 253402300799L && (num == 5 || (num7 == 0L && num8 == 0));
			if (((ZDOID)(ref id)).IsNone() || !flag || !favoriteIds.Add(normalizedFavoriteId) || !IsFinite(val) || !IsFinite(val2) || text2.Length > 256 || text3.Length > 128 || text4.Length > 128 || !Enum.IsDefined(typeof(PublicPortalAccessMode), num) || !flag2 || !flag3 || !flag4)
			{
				entry = default(PublicPortalCatalogEntry);
				return false;
			}
			entry = new PublicPortalCatalogEntry(id, normalizedFavoriteId, prefabHash, allowsAllItems, val, val2, text2, (PublicPortalAccessMode)num, new PortalOwner(text3, text4), num2, num3, num4, num5, num6, num7, num8);
			return true;
		}

		public static void Register(Game game)
		{
			if ((Object)(object)game == (Object)null)
			{
				return;
			}
			if (_sessionZNet != ZNet.instance)
			{
				BeginNetworkSession(ZNet.instance);
			}
			if (_registeredGame != game)
			{
				_registeredGame = game;
				if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
				{
					RefreshAndBroadcast();
					_serverLoopGame = game;
					((MonoBehaviour)game).StartCoroutine(ServerRefreshLoop(game));
				}
				else
				{
					RequestRefresh(force: true);
				}
			}
		}

		public static void RegisterPeer(ZNet znet, ZNetPeer peer)
		{
			if (!((Object)(object)znet == (Object)null) && peer?.m_rpc != null)
			{
				if (znet.IsServer())
				{
					peer.m_rpc.Register<int, long>("sighsorry.PortalRules.CatalogRequest.v7", (Action<ZRpc, int, long>)OnCatalogRequest);
				}
				else
				{
					peer.m_rpc.Register<ZPackage>("sighsorry.PortalRules.CatalogSnapshot.v7", (Action<ZRpc, ZPackage>)OnCatalogReceived);
				}
			}
		}

		public static void BeginNetworkSession(ZNet? znet)
		{
			if (!((Object)(object)znet == (Object)null) && _sessionZNet != znet)
			{
				InviteTravelCooldownStore.EndServerSession();
				AdminPortalBiomeDefaults.EndServerSession();
				PortalAccountStore.EndServerSession();
				ResetSessionState();
				_registeredGame = null;
				_sessionZNet = znet;
				if (znet.IsServer())
				{
					PortalAccountStore.BeginServerSession();
					AdminPortalBiomeDefaults.BeginServerSession();
				}
			}
		}

		public static void NotifyServerWorldLoaded(ZNet znet)
		{
			if (_sessionZNet != znet)
			{
				BeginNetworkSession(znet);
			}
			_worldLoaded = true;
			if (znet.IsServer())
			{
				InviteTravelCooldownStore.BeginServerSession();
			}
			if ((Object)(object)_registeredGame != (Object)null && znet.IsServer())
			{
				RefreshAndBroadcast();
			}
		}

		public static void Shutdown()
		{
			InviteTravelCooldownStore.EndServerSession();
			AdminPortalBiomeDefaults.EndServerSession();
			PortalAccountStore.EndServerSession();
			ResetSessionState();
			_registeredGame = null;
			_sessionZNet = null;
		}

		public static void ForgetPeer(ZRpc? rpc)
		{
			if (rpc != null)
			{
				LastServerRequestAt.Remove(rpc);
				LastSentViews.Remove(rpc);
			}
		}

		public static void RequestRefresh(bool force = false)
		{
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				return;
			}
			if (ZNet.instance.IsServer())
			{
				RefreshAndBroadcast();
				return;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (force || !(realtimeSinceStartup - _lastClientRequestAt < 0.5f))
			{
				ZRpc serverRPC = ZNet.instance.GetServerRPC();
				if (serverRPC != null)
				{
					_lastClientRequestAt = realtimeSinceStartup;
					serverRPC.Invoke("sighsorry.PortalRules.CatalogRequest.v7", new object[2] { _clientRevision, _clientViewToken });
				}
			}
		}

		public static void ObservePortal(ZDO zdo)
		{
			//IL_0022: 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_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			if (zdo == null || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || ServerAuthority.ContainsKey(zdo.m_uid) || PendingRemovalIds.Contains(zdo.m_uid) || !zdo.IsValid() || (!PublicPortalKinds.IsHandledPortal(zdo) && !PublicPortalServerPolicy.IsCountedPortalPrefab(zdo.GetPrefab())))
			{
				return;
			}
			bool flag = _activePortalSync != null;
			if (!_authorityBackfilled)
			{
				if (flag)
				{
					PublicPortalServerPolicy.RejectUnverifiedPortal(zdo, _activePortalSync?.Peer);
				}
				return;
			}
			if (PublicPortalKinds.IsAdminPortalPrefab(zdo.GetPrefab()))
			{
				ZNetPeer val = _activePortalSync?.Peer;
				if (flag && !IsAuthenticatedRemoteAdminPortalCreation(zdo, val))
				{
					PublicPortalServerPolicy.RejectUnverifiedPortal(zdo, val);
					PortalRulesPlugin.PortalRulesLogger.LogWarning((object)$"Rejected admin portal creation {zdo.m_uid} from a non-admin or unverified peer.");
				}
				else if (!CanInitializeAdminPortalAuthority(zdo))
				{
					if (flag)
					{
						PublicPortalServerPolicy.RejectUnverifiedPortal(zdo, val);
						PortalRulesPlugin.PortalRulesLogger.LogWarning((object)$"Rejected admin portal creation {zdo.m_uid} while biome GlobalKey defaults were unavailable.");
					}
					else
					{
						InitialWorldPortalIds.Add(zdo.m_uid);
					}
				}
				else
				{
					SetAndPersistServerAuthority(zdo, CreateAdminPortalAuthority(zdo, PublicPortalAccessMode.Public, CreateServerFavoriteId(), ResolveInitialAdminRequiredGlobalKey(zdo)), forceSend: true);
					MarkServerCatalogDirty(zdo);
				}
				return;
			}
			if (!flag && _pendingLocalPlacementPortalIds != null)
			{
				_pendingLocalPlacementPortalIds.Add(zdo.m_uid);
				return;
			}
			ServerPortalAuthority authority;
			if (InitialWorldPortalIds.Contains(zdo.m_uid))
			{
				authority = ReadInitialAuthority(zdo);
			}
			else
			{
				PortalBuilder builder;
				bool flag2 = TryResolveActiveBuilder(zdo, out builder);
				long num = zdo.GetLong(ZDOVars.s_creator, 0L);
				if (!flag2 && !flag && num != 0L)
				{
					flag2 = TryCreateRegistryBuilder(zdo, out builder);
				}
				if (!flag2)
				{
					if (flag || num != 0L)
					{
						ZNetPeer sourcePeer = _activePortalSync?.Peer;
						PublicPortalServerPolicy.RejectUnverifiedPortal(zdo, sourcePeer);
						return;
					}
					authority = CreateAuthorityForNewPortal(zdo);
				}
				else
				{
					PortalOwner owner = new PortalOwner(builder.AccountId, builder.Name);
					PortalBuilder builder2 = SanitizeBuilder(builder);
					if (!PublicPortalServerPolicy.TryAcceptNewPortal(zdo, builder2, _activePortalSync?.Peer))
					{
						return;
					}
					authority = new ServerPortalAuthority(PublicPortalAccessMode.Personal, SanitizeOwner(owner), "", builder2, zdo.GetPrefab(), CreateServerFavoriteId(), "", CreateTemporaryPublicExpirationUtcSeconds(PublicPortalAccessMode.Personal, builder2, zdo.GetPrefab()));
				}
			}
			if (TryNormalizeTemporaryPublicAuthority(authority, GetUtcNowSeconds(), out var updatedAuthority, out var _))
			{
				authority = updatedAuthority;
			}
			SetAndPersistServerAuthority(zdo, authority, forceSend: true);
			MarkServerCatalogDirty(zdo);
		}

		public static PortalSyncContext? BeginPortalSync(ZRpc rpc)
		{
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer() && _worldLoaded && !_authorityBackfilled)
			{
				RefreshAndBroadcast();
			}
			PortalSyncContext? activePortalSync = _activePortalSync;
			_activePortalSync = new PortalSyncContext(((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer()) ? PublicPortalData.FindPeer(ZNet.instance, rpc) : null);
			return activePortalSync;
		}

		public static void RestorePortalSync(PortalSyncContext? previousContext)
		{
			_activePortalSync = previousContext;
		}

		public static void ObserveRemoteZdoCreated(ZDO zdo)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (zdo != null && _activePortalSync != null)
			{
				_activePortalSync.CreatedIds.Add(zdo.m_uid);
			}
		}

		public static LocalPortalPlacementState BeginLocalPlacement(Player player)
		{
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer() && _worldLoaded && !_authorityBackfilled)
			{
				RefreshAndBroadcast();
			}
			LocalPortalPlacementState result = new LocalPortalPlacementState(_activeLocalPlacementBuilder, _pendingLocalPlacementPortalIds);
			_activeLocalPlacementBuilder = (((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer() && (Object)(object)player != (Object)null && (Object)(object)player == (Object)(object)Player.m_localPlayer && TryEnsureLocalIdentity(out string steamId)) ? SanitizeBuilder(new PortalBuilder(steamId, ((Character)player).GetHoverName(), steamId, player.GetPlayerID(), 0L)) : new PortalBuilder("", ""));
			_pendingLocalPlacementPortalIds = new HashSet<ZDOID>();
			return result;
		}

		public static void CompleteLocalPlacement(LocalPortalPlacementState state)
		{
			//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)
			HashSet<ZDOID> pendingLocalPlacementPortalIds = _pendingLocalPlacementPortalIds;
			_pendingLocalPlacementPortalIds = null;
			try
			{
				if (!((Object)(object)ZNet.instance != (Object)null) || !ZNet.instance.IsServer() || ZDOMan.instance == null || pendingLocalPlacementPortalIds == null)
				{
					return;
				}
				ZDOID[] array = pendingLocalPlacementPortalIds.ToArray();
				foreach (ZDOID val in array)
				{
					ZDO zDO = ZDOMan.instance.GetZDO(val);
					if (zDO != null && zDO.IsValid())
					{
						ObservePortal(zDO);
					}
				}
			}
			finally
			{
				_activeLocalPlacementBuilder = state.PreviousBuilder;
				_pendingLocalPlacementPortalIds = state.PreviousPendingPortalIds;
			}
		}

		internal static void TickIdentityRegistry()
		{
			if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer() && PortalAccountStore.IsActive && !(Time.realtimeSinceStartup < _nextIdentityReconcileAt))
			{
				_nextIdentityReconcileAt = Time.realtimeSinceStartup + 1f;
				TryEnsureLocalIdentity(out string _);
				PublicPortalServerPolicy.BroadcastQuotaStates();
			}
		}

		internal static bool TryEnsurePeerIdentity(ZNetPeer? peer, out string steamId)
		{
			steamId = "";
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || !PublicPortalData.TryGetPeerSteamId64(peer, out steamId) || !PublicPortalData.TryGetAuthenticatedPeerPlayerId(peer, out var playerId) || !PortalAccountStore.TryRememberIdentity(playerId, steamId, out var added))
			{
				steamId = "";
				return false;
			}
			if (added)
			{
				BackfillBuilderForCreator(playerId, steamId, peer?.m_playerName ?? "");
			}
			return true;
		}

		internal static bool TryEnsureLocalIdentity(out string steamId)
		{
			steamId = "";
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || (Object)(object)localPlayer == (Object)null || !PublicPortalData.TryGetLocalSteamId64(out steamId))
			{
				steamId = "";
				return false;
			}
			long playerID = localPlayer.GetPlayerID();
			if (!PortalAccountStore.TryRememberIdentity(playerID, steamId, out var added))
			{
				steamId = "";
				return false;
			}
			if (added)
			{
				BackfillBuilderForCreator(playerID, steamId, ((Character)localPlayer).GetHoverName());
			}
			return true;
		}

		public static bool TryGetAuthoritativeAccess(ZDOID portalId, out PublicPortalAccessMode accessMode, out PortalOwner owner)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (!PendingRemovalIds.Contains(portalId) && ServerAuthority.TryGetValue(portalId, out var value))
			{
				bool flag = IsTemporaryPublicAccessExpired(value, GetUtcNowSeconds());
				accessMode = ((!flag) ? value.AccessMode : PublicPortalAccessMode.Personal);
				owner = (flag ? new PortalOwner(value.Builder.AccountId, value.Builder.Name) : value.Owner);
				return true;
			}
			accessMode = PublicPortalAccessMode.Personal;
			owner = new PortalOwner("", "");
			return false;
		}

		internal static bool IsAuthoritativeAdminPortal(ZDOID portalId)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (!PendingRemovalIds.Contains(portalId) && ServerAuthority.TryGetValue(portalId, out var value))
			{
				return PublicPortalKinds.IsAdminPortalPrefab(value.PrefabHash);
			}
			return false;
		}

		internal static bool TryGetTemporaryPublicRemainingSeconds(ZDOID portalId, out int remainingSeconds)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			remainingSeconds = 0;
			if (!ServerAuthority.TryGetValue(portalId, out var value) || value.AccessMode != PublicPortalAccessMode.Public || value.PublicExpiresAtUtcSeconds == 0L)
			{
				return false;
			}
			long num = value.PublicExpiresAtUtcSeconds - GetUtcNowSeconds();
			if (num <= 0)
			{
				return false;
			}
			remainingSeconds = (int)Math.Min(2147483647L, num);
			return true;
		}

		internal static bool TryAuthorizeTeleport(ZNetPeer? peer, ZDOID sourcePortalId, ZDOID targetPortalId, string reservationId, out PortalTravelAuthorization authorization, out PortalTravelDenial denial)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			authorization = default(PortalTravelAuthorization);
			denial = new PortalTravelDenial(PortalTravelDenialCode.Denied, "", 0L, 0L);
			if (!TryCreateRemoteAuthorizationContext(peer, out RecipientContext recipient, out Vector3 playerPosition))
			{
				return false;
			}
			return TryAuthorizeTeleport(recipient, playerPosition, sourcePortalId, targetPortalId, requireConnectedPortal: false, reservationId, out authorization, out denial);
		}

		internal static bool TryAuthorizeLocalTeleport(ZDOID sourcePortalId, ZDOID targetPortalId, string reservationId, out PortalTravelAuthorization authorization, out PortalTravelDenial denial)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			CreateLocalAuthorizationContext(out RecipientContext recipient, out Vector3 playerPosition);
			return TryAuthorizeTeleport(recipient, playerPosition, sourcePortalId, targetPortalId, requireConnectedPortal: false, reservationId, out authorization, out denial);
		}

		internal static bool TryAuthorizeConnectedTeleport(ZNetPeer? peer, ZDOID sourcePortalId, ZDOID targetPortalId, string reservationId, out PortalTravelAuthorization authorization, out PortalTravelDenial denial)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			authorization = default(PortalTravelAuthorization);
			denial = new PortalTravelDenial(PortalTravelDenialCode.Denied, "", 0L, 0L);
			if (!TryCreateRemoteAuthorizationContext(peer, out RecipientContext recipient, out Vector3 playerPosition))
			{
				return false;
			}
			return TryAuthorizeTeleport(recipient, playerPosition, sourcePortalId, targetPortalId, requireConnectedPortal: true, reservationId, out authorization, out denial);
		}

		internal static bool TryAuthorizeLocalConnectedTeleport(ZDOID sourcePortalId, ZDOID targetPortalId, string reservationId, out PortalTravelAuthorization authorization, out PortalTravelDenial denial)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			CreateLocalAuthorizationContext(out RecipientContext recipient, out Vector3 playerPosition);
			return TryAuthorizeTeleport(recipient, playerPosition, sourcePortalId, targetPortalId, requireConnectedPortal: true, reservationId, out authorization, out denial);
		}

		internal static bool TryAuthorizeMapOpen(ZNetPeer? peer, ZDOID sourcePortalId, out PortalTravelDenial denial)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			denial = new PortalTravelDenial(PortalTravelDenialCode.Denied, "", 0L, 0L);
			if (PublicPortalConfig.EnablePortalMap.Value.IsOff() || !TryCreateRemoteAuthorizationContext(peer, out RecipientContext recipient, out Vector3 playerPosition))
			{
				return false;
			}
			ZDO sourcePortal;
			ServerPortalAuthority sourceAuthority;
			return TryAuthorizePortalSource(recipient, playerPosition, sourcePortalId, requireConnectedPortal: false, out sourcePortal, out sourceAuthority, out denial);
		}

		internal static bool TryAuthorizeLocalMapOpen(ZDOID sourcePortalId, out PortalTravelDenial denial)
		{
			//IL_0032: 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)
			denial = new PortalTravelDenial(PortalTravelDenialCode.Denied, "", 0L, 0L);
			if (PublicPortalConfig.EnablePortalMap.Value.IsOff())
			{
				return false;
			}
			CreateLocalAuthorizationContext(out RecipientContext recipient, out Vector3 playerPosition);
			ZDO sourcePortal;
			ServerPortalAuthority sourceAuthority;
			return TryAuthorizePortalSource(recipient, playerPosition, sourcePortalId, requireConnectedPortal: false, out sourcePortal, out sourceAuthority, out denial);
		}

		public static bool SetAuthoritativeAccess(ZDO zdo, PublicPortalAccessMode accessMode, string authorizedClanId)
		{
			//IL_0022: 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 (zdo == null || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || PendingRemovalIds.Contains(zdo.m_uid) || !ServerAuthority.TryGetValue(zdo.m_uid, out var value))
			{
				return false;
			}
			if (TryNormalizeTemporaryPublicAuthority(value, GetUtcNowSeconds(), out var updatedAuthority, out var _))
			{
				value = updatedAuthority;
			}
			string text = SanitizeClanId(authorizedClanId);
			bool flag = PublicPortalKinds.IsAdminPortalPrefab(value.PrefabHash);
			if (flag && !IsAllowedAdminPortalMode(accessMode))
			{
				return false;
			}
			PortalBuilder builder = (flag ? new PortalBuilder("", "") : value.Builder);
			if (!flag && !builder.IsValid)
			{
				return false;
			}
			PortalOwner portalOwner = (flag ? new PortalOwner("", "") : new PortalOwner(builder.AccountId, builder.Name));
			if (flag)
			{
				text = "";
			}
			if (!flag && accessMode == PublicPortalAccessMode.Invite && value.AccessMode != PublicPortalAccessMode.Invite)
			{
				int effectiveInvitePortalLimit = PortalAccountStore.GetEffectiveInvitePortalLimit(builder.AccountId, PublicPortalConfig.MaxInvitePortalsPerAccount.Value);
				if (effectiveInvitePortalLimit >= 0 && GetBuilderInvitePortalCount(builder.AccountId) >= effectiveInvitePortalLimit)
				{
					return false;
				}
			}
			bool flag2 = !flag;
			if (flag2)
			{
				bool flag3 = (uint)(accessMode - 3) <= 1u;
				flag2 = flag3;
			}
			if (flag2)
			{
				PortalClanMembership membership;
				bool flag4 = ClanPortalAccess.TryResolveBuilderMembership(builder, out membership) && membership.HasPrimaryClan;
				if (accessMode == PublicPortalAccessMode.Clan && !flag4)
				{
					return false;
				}
				text = (flag4 ? SanitizeClanId(membership.PrimaryClanId) : "");
				if (accessMode == PublicPortalAccessMode.Clan && string.IsNullOrWhiteSpace(text))
				{
					return false;
				}
				if (accessMode == PublicPortalAccessMode.Clan && (value.AccessMode != PublicPortalAccessMode.Clan || !string.Equals(value.AuthorizedClanId, text, StringComparison.Ordinal)))
				{
					int num = Math.Max(-1, Math.Min(10000, PublicPortalConfig.MaxClanPortalsPerClan.Value));
					if (num >= 0 && GetClanPortalCount(text) >= num)
					{
						return false;
					}
				}
			}
			long publicExpiresAtUtcSeconds = ((accessMode == PublicPortalAccessMode.Public && value.AccessMode == PublicPortalAccessMode.Public) ? value.PublicExpiresAtUtcSeconds : CreateTemporaryPublicExpirationUtcSeconds(accessMode, builder, value.PrefabHash));
			PortalOwner owner = portalOwner;
			flag2 = (uint)(accessMode - 3) <= 1u;
			ServerPortalAuthority authority = new ServerPortalAuthority(accessMode, owner, flag2 ? text : "", builder, value.PrefabHash, value.FavoriteId, value.RequiredGlobalKey, publicExpiresAtUtcSeconds);
			SetAndPersistServerAuthority(zdo, authority, forceSend: true);
			RefreshAndBroadcast();
			return true;
		}

		internal static bool SetAuthoritativeAdminPortalTag(ZDO zdo, string tag)
		{
			//IL_0022: 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_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			if (zdo == null || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || PendingRemovalIds.Contains(zdo.m_uid) || !ServerAuthority.TryGetValue(zdo.m_uid, out var value) || !PublicPortalKinds.IsAdminPortalPrefab(value.PrefabHash))
			{
				return false;
			}
			AdminPortalTags[zdo.m_uid] = new AdminPortalTagAuthority(Truncate(tag, 10));
			zdo.UpdateConnection((ConnectionType)1, ZDOID.None);
			WriteAuthorityToZdo(zdo, value, forceSend: true);
			RefreshAndBroadcast();
			PublicPortalTaggedConnections.RefreshConnections();
			return true;
		}

		internal static bool SetAuthoritativeAdminPortalRequiredGlobalKey(ZDO zdo, string requiredGlobalKey)
		{
			//IL_0022: 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 (zdo == null || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || PendingRemovalIds.Contains(zdo.m_uid) || !ServerAuthority.TryGetValue(zdo.m_uid, out var value) || !PublicPortalKinds.IsAdminPortalPrefab(value.PrefabHash) || !PublicPortalData.TryNormalizeRequiredGlobalKey(requiredGlobalKey, out string normalized, out RequiredGlobalKeyValidationFailure _))
			{
				return false;
			}
			ServerPortalAuthority authority = new ServerPortalAuthority(value.AccessMode, value.Owner, value.AuthorizedClanId, value.Builder, value.PrefabHash, value.FavoriteId, normalized, value.PublicExpiresAtUtcSeconds);
			SetAndPersistServerAuthority(zdo, authority, forceSend: true);
			RefreshAndBroadcast();
			return true;
		}

		internal static int GetBuilderPortalCount(string builderAccountId)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			if (!PublicPortalData.TryNormalizeSteamId64(builderAccountId, out string steamId) || !ServerPortalsByBuilder.TryGetValue(steamId, out HashSet<ZDOID> value))
			{
				return 0;
			}
			int num = 0;
			foreach (ZDOID item in value)
			{
				if (!PendingRemovalIds.Contains(item) && ServerAuthority.TryGetValue(item, out var value2) && PublicPortalServerPolicy.IsCountedPortalPrefab(value2.PrefabHash))
				{
					num++;
				}
			}
			return num;
		}

		internal static int GetBuilderInvitePortalCount(string builderAccountId)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			if (!PublicPortalData.TryNormalizeSteamId64(builderAccountId, out string steamId) || !ServerPortalsByBuilder.TryGetValue(steamId, out HashSet<ZDOID> value))
			{
				return 0;
			}
			int num = 0;
			foreach (ZDOID item in value)
			{
				if (!PendingRemovalIds.Contains(item) && ServerAuthority.TryGetValue(item, out var value2) && value2.Builder.IsValid && value2.AccessMode == PublicPortalAccessMode.Invite && !PublicPortalKinds.IsAdminPortalPrefab(value2.PrefabHash))
				{
					num++;
				}
			}
			return num;
		}

		internal static int GetClanPortalCount(string clanId)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			string text = SanitizeClanId(clanId);
			if (string.IsNullOrEmpty(text))
			{
				return 0;
			}
			int num = 0;
			foreach (KeyValuePair<ZDOID, ServerPortalAuthority> item in ServerAuthority)
			{
				ServerPortalAuthority value = item.Value;
				if (!PendingRemovalIds.Contains(item.Key) && value.Builder.IsValid && value.AccessMode == PublicPortalAccessMode.Clan && !PublicPortalKinds.IsAdminPortalPrefab(value.PrefabHash) && string.Equals(value.AuthorizedClanId, text, StringComparison.Ordinal))
				{
					num++;
				}
			}
			return num;
		}

		internal static bool TryGetAuthoritativeBuilder(ZDOID portalId, out PortalBuilder builder)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (!PendingRemovalIds.Contains(portalId) && ServerAuthority.TryGetValue(portalId, out var value))
			{
				builder = value.Builder;
				return true;
			}
			builder = new PortalBuilder("", "");
			return false;
		}

		internal static bool MarkPendingRemoval(ZDOID portalId)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (((ZDOID)(ref portalId)).IsNone() || !PendingRemovalIds.Add(portalId))
			{
				return false;
			}
			MarkServerCatalogDirty();
			return true;
		}

		internal static void NotifyPortalDestroyed(ZDOID portalId)
		{
			//IL_0000: 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_0017: Unknown result type (might be due to invalid IL or missing references)
			RemoveServerAuthority(portalId);
			PendingRemovalIds.Remove(portalId);
			InitialWorldPortalIds.Remove(portalId);
			MarkServerCatalogDirty();
		}

		internal static bool TryGetClientEntry(ZDOID portalId, out PublicPortalCatalogEntry entry)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return ClientIndex.TryGetValue(portalId, out entry);
		}

		internal static bool TryCanLocalServerUserUsePortal(ZDOID portalId, out bool canUse)
		{
			//IL_0021: 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)
			canUse = false;
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || PendingRemovalIds.Contains(portalId) || !ServerAuthority.TryGetValue(portalId, out var value))
			{
				return false;
			}
			RecipientContext recipient = CreateRecipientContext(PublicPortalData.LocalOwner(), PortalRulesPlugin.IsAdmin, ResolveLocalMembership());
			canUse = CanRecipientUseAuthority(value, recipient);
			return true;
		}

		public static PublicPortalAccessMode GetEffectiveAccessMode(ZDO zdo)
		{
			//IL_0009: 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_0047: Unknown result type (might be due to invalid IL or missing references)
			if (zdo != null)
			{
				if (PendingRemovalIds.Contains(zdo.m_uid))
				{
					return PublicPortalAccessMode.Personal;
				}
				if (ServerAuthority.TryGetValue(zdo.m_uid, out var value))
				{
					if (!IsTemporaryPublicAccessExpired(value, GetUtcNowSeconds()))
					{
						return value.AccessMode;
					}
					return PublicPortalAccessMode.Personal;
				}
				if (ClientIndex.TryGetValue(zdo.m_uid, out var value2))
				{
					return value2.AccessMode;
				}
			}
			if (zdo == null)
			{
				return PublicPortalAccessMode.Personal;
			}
			return PublicPortalData.GetAccessMode(zdo);
		}

		public static PortalOwner GetEffectiveOwner(ZDO zdo)
		{
			//IL_000c: 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_0072: Unknown result type (might be due to invalid IL or missing references)
			if (zdo != null)
			{
				if (PendingRemovalIds.Contains(zdo.m_uid))
				{
					return new PortalOwner("", "");
				}
				if (ServerAuthority.TryGetValue(zdo.m_uid, out var value))
				{
					if (!IsTemporaryPublicAccessExpired(value, GetUtcNowSeconds()))
					{
						return value.Owner;
					}
					return new PortalOwner(value.Builder.AccountId, value.Builder.Name);
				}
				if (ClientIndex.TryGetValue(zdo.m_uid, out var value2))
				{
					return value2.Owner;
				}
			}
			if (zdo == null)
			{
				return new PortalOwner("", "");
			}
			return PublicPortalData.GetOwner(zdo);
		}

		internal static string GetEffectiveAuthorizedClanId(ZDO zdo)
		{
			//IL_0009: 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)
			if (zdo == null || PendingRemovalIds.Contains(zdo.m_uid))
			{
				return "";
			}
			if (!ServerAuthority.TryGetValue(zdo.m_uid, out var value))
			{
				return SanitizeClanId(PublicPortalData.GetAuthorizedClanId(zdo));
			}
			return value.AuthorizedClanId;
		}

		internal static string GetEffectiveRequiredGlobalKey(ZDO zdo)
		{
			//IL_0009: 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)
			if (zdo == null || PendingRemovalIds.Contains(zdo.m_uid))
			{
				return "";
			}
			if (!ServerAuthority.TryGetValue(zdo.m_uid, out var value))
			{
				return PublicPortalData.GetRequiredGlobalKey(zdo);
			}
			return value.RequiredGlobalKey;
		}

		public static void RefreshAndBroadcast()
		{
			if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer())
			{
				bool num = RefreshServerSnapshot();
				RefreshLocalRecipientView(num);
				if (num)
				{
					BroadcastSnapshot();
				}
				else
				{
					BroadcastChangedViews();
				}
				PublicPortalServerPolicy.BroadcastQuotaStates();
			}
		}

		internal static void RefreshCountedPortalConfiguration()
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			if (ZDOMan.instance != null)
			{
				foreach (ZDO portal in ZDOMan.instance.GetPortals())
				{
					if (portal != null && portal.IsValid())
					{
						InitialWorldPortalIds.Add(portal.m_uid);
					}
				}
			}
			RefreshAndBroadcast();
		}

		internal static void RefreshTemporaryPublicConfiguration()
		{
			//IL_0052: 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 ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || ZDOMan.instance == null || !_authorityBackfilled)
			{
				return;
			}
			long utcNowSeconds = GetUtcNowSeconds();
			int num = 0;
			KeyValuePair<ZDOID, ServerPortalAuthority>[] array = ServerAuthority.ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				KeyValuePair<ZDOID, ServerPortalAuthority> keyValuePair = array[i];
				if (PendingRemovalIds.Contains(keyValuePair.Key))
				{
					continue;
				}
				ZDO zDO = ZDOMan.instance.GetZDO(keyValuePair.Key);
				if (zDO != null && zDO.IsValid())
				{
					long num2 = CreateTemporaryPublicExpirationUtcSeconds(keyValuePair.Value.AccessMode, keyValuePair.Value.Builder, keyValuePair.Value.PrefabHash, utcNowSeconds);
					if (num2 != keyValuePair.Value.PublicExpiresAtUtcSeconds)
					{
						ServerPortalAuthority authority = new ServerPortalAuthority(keyValuePair.Value.AccessMode, keyValuePair.Value.Owner, keyValuePair.Value.AuthorizedClanId, keyValuePair.Value.Builder, keyValuePair.Value.PrefabHash, keyValuePair.Value.FavoriteId, keyValuePair.Value.RequiredGlobalKey, num2);
						SetAndPersistServerAuthority(zDO, authority, forceSend: true);
						num++;
					}
				}
			}
			if (num > 0)
			{
				PortalRulesPlugin.PortalRulesLogger.LogInfo((object)$"Reset temporary Public access for {num} portal(s) after a duration configuration change.");
			}
			RefreshAndBroadcast();
		}

		internal static void RefreshInviteCooldownConfiguration()
		{
			if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer() && _hasSnapshot)
			{
				RefreshLocalClientEntries(forceUpdate: true);
				BroadcastSnapshot();
			}
		}

		private static void MarkServerCatalogDirty(ZDO portal)
		{
			if (PublicPortalKinds.IsHandledPortal(portal) || PublicPortalServerPolicy.IsCountedPortalPrefab(portal.GetPrefab()))
			{
				MarkServerCatalogDirty();
			}
		}

		private static void MarkServerCatalogDirty()
		{
			_serverCatalogDirty = true;
			Game registeredGame = _registeredGame;
			ZNet sessionZNet = _sessionZNet;
			if (!_serverDirtyFlushScheduled && _worldLoaded && !((Object)(object)registeredGame == (Object)null) && !((Object)(object)sessionZNet == (Object)null) && ZNet.instance == sessionZNet && sessionZNet.IsServer())
			{
				_serverDirtyFlushScheduled = true;
				((MonoBehaviour)registeredGame).StartCoroutine(FlushDirtyServerCatalogNextFrame(registeredGame, sessionZNet, _sessionGeneration));
			}
		}

		private static IEnumerator FlushDirtyServerCatalogNextFrame(Game game, ZNet sessionZNet, long generation)
		{
			yield return null;
			if (generation == _sessionGeneration && _registeredGame == game && _sessionZNet == sessionZNet && ZNet.instance == sessionZNet && _worldLoaded && sessionZNet.IsServer())
			{
				_serverDirtyFlushScheduled = false;
				if (_serverCatalogDirty)
				{
					_serverCatalogDirty = false;
					RefreshAndBroadcast();
				}
			}
		}

		internal static void RefreshClanViews()
		{
			if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer() && _hasSnapshot)
			{
				RefreshLocalRecipientView(catalogChanged: false);
				BroadcastChangedViews();
			}
		}

		public static void ReconcileAuthorityToZdos()
		{
			//IL_003f: 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)
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || ZDOMan.instance == null)
			{
				return;
			}
			KeyValuePair<ZDOID, ServerPortalAuthority>[] array = ServerAuthority.ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				KeyValuePair<ZDOID, ServerPortalAuthority> keyValuePair = array[i];
				if (!PendingRemovalIds.Contains(keyValuePair.Key))
				{
					ZDO zDO = ZDOMan.instance.GetZDO(keyValuePair.Key);
					if (zDO != null && zDO.IsValid() && !ZdoMatchesAuthority(zDO, keyValuePair.Value))
					{
						WriteAuthorityToZdo(zDO, keyValuePair.Value, forceSend: false);
					}
				}
			}
		}

		private static IEnumerator ServerRefreshLoop(Game game)
		{
			yield return (object)new WaitForSeconds(1f);
			while (_serverLoopGame == game && _registeredGame == game && (Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
			{
				RefreshAndBroadcast();
				yield return (object)new WaitForSeconds(5f);
			}
		}

		private static void OnCatalogRequest(ZRpc rpc, int knownRevision, long knownViewToken)
		{
			ZNet instance = ZNet.instance;
			if ((Object)(object)instance == (Object)null || !instance.IsServer())
			{
				return;
			}
			ZNetPeer val = PublicPortalData.FindPeer(instance, rpc);
			if (val == null || !val.IsReady())
			{
				PortalRulesPlugin.PortalRulesLogger.LogDebug((object)"Rejected a portal catalog request from an unauthenticated connection.");
				return;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			float value2;
			if (_hasSnapshot && knownRevision == _serverRevision && LastSentViews.TryGetValue(rpc, out var value) && knownViewToken != 0L && knownViewToken == value.ViewToken && PublicPortalData.TryGetPeerOwner(val, out var owner) && value.MatchesRecipient(_serverRevision, SanitizeOwner(owner).Id, PublicPortalData.IsPeerAdmin(instance, val)))
			{
				LastSentViews[rpc] = value.WithAcknowledgement();
			}
			else if (!LastServerRequestAt.TryGetValue(rpc, out value2) || !(realtimeSinceStartup - value2 < 30f))
			{
				LastServerRequestAt[rpc] = realtimeSinceStartup;
				if (!_hasSnapshot)
				{
					RefreshServerSnapshot();
				}
				RecipientContext recipient = CreateRecipientContext(val);
				ulong fingerprint;
				List<PublicPortalCatalogEntry> visibleEntries = BuildRecipientEntries(recipient, out fingerprint);
				SendSnapshot(rpc, val, recipient, visibleEntries, fingerprint);
			}
		}

		private static void OnCatalogReceived(ZRpc rpc, ZPackage package)
		{
			if ((Object)(object)ZNet.instance == (Object)null || ZNet.instance.IsServer() || rpc != ZNet.instance.GetServerRPC())
			{
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)"Ignored portal catalog data from a non-server connection.");
				return;
			}
			try
			{
				byte b = package.ReadByte();
				if (b != 7)
				{
					PortalRulesPlugin.PortalRulesLogger.LogWarning((object)$"Ignored portal catalog format {b}; expected {(byte)7}.");
					return;
				}
				int num = package.ReadInt();
				long num2 = package.ReadLong();
				int num3 = package.ReadInt();
				int num4 = package.ReadInt();
				int num5 = package.ReadInt();
				string text = package.ReadString();
				bool flag = package.ReadBool();
				long num6 = package.ReadLong();
				int num7 = package.ReadInt();
				int num8 = Math.Max(1, (num5 + 96 - 1) / 96);
				if (num < 0 || num2 == 0L || num < _clientRevision || num3 < 0 || num4 < 1 || num4 > 1042 || num3 >= num4 || num5 < 0 || num5 > 100000 || num4 != num8 || text.Length > 128 || num7 < 0 || num7 > 96 || num7 > num5 || num6 <= 0 || num6 > 253402300799L)
				{
					PortalRulesPlugin.PortalRulesLogger.LogWarning((object)($"Ignored malformed portal catalog chunk {num3}/{num4} " + $"for revision {num}."));
					ResetPendingSnapshot();
					return;
				}
				PendingSnapshot pendingSnapshot = _pendingSnapshot;
				if (num3 == 0)
				{
					pendingSnapshot = (_pendingSnapshot = new PendingSnapshot(num, num2, num4, num5, text, flag, num6));
				}
				else if (pendingSnapshot == null || num != pendingSnapshot.Revision || num2 != pendingSnapshot.ViewToken || num4 != pendingSnapshot.ChunkCount || num3 != pendingSnapshot.NextChunk || num5 != pendingSnapshot.TotalCount || !string.Equals(text, pendingSnapshot.RecipientOwnerId, StringComparison.Ordinal) || flag != pendingSnapshot.RecipientIsAdmin || num6 != pendingSnapshot.ServerUtcAtSend)
				{
					PortalRulesPlugin.PortalRulesLogger.LogWarning((object)$"Ignored out-of-sequence portal catalog chunk {num3}/{num4}.");
					ResetPendingSnapshot();
					return;
				}
				PendingSnapshot pendingSnapshot2 = pendingSnapshot;
				List<PublicPortalCatalogEntry> list = new List<PublicPortalCatalogEntry>(num7);
				for (int i = 0; i < num7; i++)
				{
					if (!TryReadCatalogEntry(package, pendingSnapshot2.FavoriteIds, out var entry))
					{
						PortalRulesPlugin.PortalRulesLogger.LogWarning((object)$"Ignored malformed portal catalog entry at index {i}.");
						ResetPendingSnapshot();
						return;
					}
					list.Add(entry);
				}
				pendingSnapshot2.Entries.AddRange(list);
				pendingSnapshot2.NextChunk++;
				if (pendingSnapshot2.NextChunk < pendingSnapshot2.ChunkCount)
				{
					return;
				}
				if (pendingSnapshot2.Entries.Count != pendingSnapshot2.TotalCount)
				{
					PortalRulesPlugin.PortalRulesLogger.LogWarning((object)($"Ignored incomplete portal catalog revision {pendingSnapshot2.Revision}: " + $"expected {pendingSnapshot2.TotalCount}, " + $"received {pendingSnapshot2.Entries.Count}."));
					ResetPendingSnapshot();
					return;
				}
				List<PublicPortalCatalogEntry> entries = pendingSnapshot2.Entries;
				int revision = pendingSnapshot2.Revision;
				long viewToken = pendingSnapshot2.ViewToken;
				string recipientOwnerId = pendingSnapshot2.RecipientOwnerId;
				bool recipientIsAdmin = pendingSnapshot2.RecipientIsAdmin;
				long serverUtcAtSend = pendingSnapshot2.ServerUtcAtSend;
				long firstChunkReceivedTimestamp = pendingSnapshot2.FirstChunkReceivedTimestamp;
				ResetPendingSnapshot();
				SynchronizeClientServerClock(serverUtcAtSend, firstChunkReceivedTimestamp);
				bool flag2 = !string.Equals(PublicPortalData.ServerAssignedOwnerId, recipientOwnerId, StringComparison.Ordinal) || PublicPortalData.ServerAssignedIsAdmin != recipientIsAdmin;
				if (_hasSnapshot && revision == _clientRevision && SnapshotsMatch(ClientEntries, entries))
				{
					PublicPortalData.SetServerAssignedOwnerId(recipientOwnerId);
					PublicPortalData.SetServerAssignedIsAdmin(recipientIsAdmin);
					_clientViewToken = viewToken;
					if (flag2)
					{
						PublicPortalCatalog.Updated?.Invoke();
					}
					AcknowledgeSnapshot(revision, viewToken);
				}
				else
				{
					_clientRevision = revision;
					_clientViewToken = viewToken;
					_hasSnapshot = true;
					PublicPortalData.SetServerAssignedOwnerId(recipientOwnerId);
					PublicPortalData.SetServerAssignedIsAdmin(recipientIsAdmin);
					ClientEntries.Clear();
					ClientEntries.AddRange(entries);
					RebuildClientIndex();
					PublicPortalCatalog.Updated?.Invoke();
					AcknowledgeSnapshot(revision, viewToken);
				}
			}
			catch (Exception ex)
			{
				ResetPendingSnapshot();
				PortalRulesPlugin.PortalRulesLogger.LogError((object)("Failed to read portal catalog: " + ex.Message));
			}
		}

		private static bool RefreshServerSnapshot()
		{
			//IL_0135: 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_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0423: Unknown result type (might be due to invalid IL or missing references)
			//IL_0428: Unknown result type (might be due to invalid IL or missing references)
			//IL_042f: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0480: Unknown result type (might be due to invalid IL or missing references)
			//IL_0485: Unknown result type (might be due to invalid IL or missing references)
			//IL_048c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			//IL_029d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b1: 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_0301: Unknown result type (might be due to invalid IL or missing references)
			//IL_0303: Unknown result type (might be due to invalid IL or missing references)
			if (!_worldLoaded || ZDOMan.instance == null)
			{
				return false;
			}
			PortalAccountStore.BeginServerSession();
			AdminPortalBiomeDefaults.BeginServerSession();
			if (!AdminPortalBiomeDefaults.IsBiomeRegistryReady)
			{
				return false;
			}
			AdminPortalBiomeDefaults.EnsureTemplateReady();
			TryEnsureLocalIdentity(out string steamId);
			if ((Object)(object)ZNet.instance != (Object)null)
			{
				ZNetPeer[] array = ZNet.instance.GetPeers().ToArray();
				foreach (ZNetPeer val in array)
				{
					if (val != null && val.IsReady())
					{
						TryEnsurePeerIdentity(val, out steamId);
					}
				}
			}
			bool flag = !_authorityBackfilled;
			long utcNowSeconds = GetUtcNowSeconds();
			int num = 0;
			int num2 = 0;
			HashSet<ZDOID> livePortalIds = new HashSet<ZDOID>();
			List<PublicPortalCatalogEntry> list = new List<PublicPortalCatalogEntry>();
			ZDO[] array2 = (from portal in ZDOMan.instance.GetPortals()
				where portal != null
				orderby portal.m_uid
				select portal).ToArray();
			SeedNextBuildSequence(array2);
			ZDO[] array3 = array2;
			foreach (ZDO val2 in array3)
			{
				if (val2 == null || !val2.IsValid())
				{
					continue;
				}
				livePortalIds.Add(val2.m_uid);
				if (PendingRemovalIds.Contains(val2.m_uid))
				{
					continue;
				}
				if (flag)
				{
					InitialWorldPortalIds.Add(val2.m_uid);
				}
				if (PublicPortalKinds.IsAdminPortalPrefab(val2.GetPrefab()) && !ServerAuthority.ContainsKey(val2.m_uid) && !CanInitializeAdminPortalAuthority(val2))
				{
					continue;
				}
				bool flag2 = false;
				if (ServerAuthority.TryGetValue(val2.m_uid, out var value))
				{
					if (TryBackfillAuthorityBuilder(val2, value, out var updatedAuthority))
					{
						value = updatedAuthority;
						flag2 = true;
					}
				}
				else
				{
					if (!PublicPortalKinds.IsHandledPortal(val2) && !PublicPortalServerPolicy.IsCountedPortalPrefab(val2.GetPrefab()))
					{
						continue;
					}
					value = ((flag || InitialWorldPortalIds.Contains(val2.m_uid)) ? ReadInitialAuthority(val2) : CreateAuthorityForNewPortal(val2));
					flag2 = true;
				}
				if (TryNormalizeTemporaryPublicAuthority(value, utcNowSeconds, out var updatedAuthority2, out var revertedToPersonal))
				{
					value = updatedAuthority2;
					flag2 = true;
					if (revertedToPersonal)
					{
						num++;
					}
				}
				if (TryNormalizeDisabledInviteAuthority(value, out var updatedAuthority3))
				{
					value = updatedAuthority3;
					flag2 = true;
					num2++;
				}
				if (flag2)
				{
					SetAndPersistServerAuthority(val2, value, forceSend: true);
				}
				else if (!ZdoMatchesAuthority(val2, value))
				{
					PortalRulesPlugin.PortalRulesLogger.LogDebug((object)$"Restoring server-authoritative access data for portal {val2.m_uid}.");
					WriteAuthorityToZdo(val2, value, forceSend: true);
				}
				if (PublicPortalKinds.IsHandledPortal(val2))
				{
					Vector3 position = val2.GetPosition();
					Quaternion rotation = val2.GetRotation();
					if (!IsSafePortalPosition(position) || !TryNormalizePortalRotation(rotation, out var normalized))
					{
						PortalRulesPlugin.PortalRulesLogger.LogWarning((object)$"Skipped portal {val2.m_uid} with invalid transform data.");
					}
					else
					{
						list.Add(new PublicPortalCatalogEntry(val2.m_uid, value.FavoriteId, value.PrefabHash, PublicPortalKinds.PrefabAllowsAllItems(value.PrefabHash), position, normalized, Truncate(val2.GetString(ZDOVars.s_tag, ""), 256), value.AccessMode, value.Owner, 0, 0, 0, 0, 0, 0L, 0L));
					}
				}
			}
			if (num > 0)
			{
				PortalRulesPlugin.PortalRulesLogger.LogInfo((object)$"Returned {num} expired Public portal(s) to their Builder's Personal access.");
			}
			if (num2 > 0)
			{
				PortalRulesPlugin.PortalRulesLogger.LogInfo((object)$"Returned {num2} Invite portal(s) with an effective zero Invite limit to their Builder's Personal access.");
			}
			ZDOID[] array4 = ServerAuthority.Keys.Where((ZDOID id) => !livePortalIds.Contains(id)).ToArray();
			for (int i = 0; i < array4.Length; i++)
			{
				RemoveServerAuthority(array4[i]);
			}
			array4 = InitialWorldPortalIds.Where((ZDOID id) => !livePortalIds.Contains(id)).ToArray();
			foreach (ZDOID item in array4)
			{
				InitialWorldPortalIds.Remove(item);
			}
			array4 = PendingRemovalIds.Where((ZDOID id) => !livePortalIds.Contains(id)).ToArray();
			foreach (ZDOID item2 in array4)
			{
				PendingRemovalIds.Remove(item2);
			}
			ApplyModeDisplayMetadata(list);
			list.Sort(delegate(PublicPortalCatalogEntry left, PublicPortalCatalogEntry right)
			{
				//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_000a: Unknown result type (might be due to invalid IL or missing references)
				ZDOID id = left.Id;
				return ((ZDOID)(ref id)).CompareTo(right.Id);
			});
			if (list.Count > 100000)
			{
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)$"Portal catalog exceeded {100000} entries; truncating the snapshot.");
				list.RemoveRange(100000, list.Count - 100000);
			}
			_authorityBackfilled = true;
			bool num3 = !_hasSnapshot;
			_hasSnapshot = true;
			if (!num3 && SnapshotsMatch(ServerEntries, list))
			{
				return false;
			}
			ServerEntries.Clear();
			ServerEntries.AddRange(list);
			_serverRevision++;
			return true;
		}

		private static ServerPortalAuthority ReadInitialAuthority(ZDO portal)
		{
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			string text = ReadInitialFavoriteId(portal);
			int num = portal.GetInt("PortalRules AuthorityVersion", 0);
			if (PublicPortalKinds.IsAdminPortalPrefab(portal.GetPrefab()))
			{
				string favoriteId = text;
				string requiredGlobalKey = ResolveInitialAdminRequiredGlobalKey(portal);
				return CreateAdminPortalAuthority(portal, null, favoriteId, requiredGlobalKey);
			}
			int num2 = portal.GetInt("PortalRules AccessMode", -1);
			bool flag = Enum.IsDefined(typeof(PublicPortalAccessMode), num2) && (num2 != 5 || num >= 6);
			PortalOwner owner = SanitizeOwner(PublicPortalData.GetOwner(portal));
			bool flag2 = num >= 1;
			bool flag3 = num >= 3 && owner.IsValid;
			if (flag3)
			{
				bool flag4 = (uint)(num2 - 3) <= 1u;
				flag3 = flag4;
			}
			string authorizedClanId = (flag3 ? SanitizeClanId(PublicPortalData.GetAuthorizedClanId(portal)) : "");
			bool num3 = portal.GetInt("PortalRules BuilderAuthorityVersion", 0) >= 2;
			PortalBuilder builder = (num3 ? SanitizeBuilder(PublicPortalData.GetBuilder(portal)) : new PortalBuilder("", ""));
			int num4 = (num3 ? portal.GetInt("PortalRules AuthorizedPrefabHash", portal.GetPrefab()) : portal.GetPrefab());
			if (num4 == 0)
			{
				num4 = portal.GetPrefab();
			}
			if (!flag2 && owner.IsValid)
			{
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)($"Portal {portal.m_uid} has legacy ownership that was not server-authorized; " + "a server admin must reclaim it."));
				owner = new PortalOwner("", "");
			}
			if (!builder.IsValid && TryCreateRegistryBuilder(portal, out var builder2))
			{
				builder = builder2;
			}
			int num5;
			switch (num2)
			{
			case 2:
				num5 = ((owner.IsValid || portal.GetLong(ZDOVars.s_creator, 0L) != 0) ? 1 : 0);
				break;
			default:
				num5 = 0;
				break;
			case 3:
			case 4:
			case 5:
				num5 = 1;
				break;
			}
			bool flag5 = (byte)num5 != 0;
			if (flag && flag5 && !builder.IsValid)
			{
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)($"Portal {portal.m_uid} had {(PublicPortalAccessMode)num2} access " + "without valid current Builder authority; it was changed to Personal."));
				num2 = 0;
				authorizedClanId = "";
			}
			if (flag && (flag2 || owner.IsValid))
			{
				return new ServerPortalAuthority((PublicPortalAccessMode)num2, owner, authorizedClanId, builder, num4, text, "", (num >= 5) ? PublicPortalData.GetPublicExpiresAtUtcSeconds(portal) : 0);
			}
			if (flag)
			{
				return new ServerPortalAuthority((PublicPortalAccessMode)num2, new PortalOwner("", ""), "", builder, num4, text, "", (num >= 5) ? PublicPortalData.GetPublicExpiresAtUtcSeconds(portal) : 0);
			}
			return new ServerPortalAuthority(PublicPortalAccessMode.Personal, new PortalOwner("", ""), "", builder, num4, text, "", 0L);
		}

		private static bool TryCreateRegistryBuilder(ZDO portal, out PortalBuilder builder, string fallbackName = "")
		{
			builder = new PortalBuilder("", "");
			if (portal == null || PublicPortalKinds.IsAdminPortalPrefab(portal.GetPrefab()))
			{
				return false;
			}
			long num = portal.GetLong(ZDOVars.s_creator, 0L);
			if (num == 0L || !PortalAccountStore.TryResolveSteamId(num, out string steamId))
			{
				return false;
			}
			string text = portal.GetString(ZDOVars.s_creatorName, "");
			builder = SanitizeBuilder(new PortalBuilder(steamId, string.IsNullOrWhiteSpace(text) ? fallbackName : text, steamId, num, 0L));
			return builder.IsValid;
		}

		private static bool TryBackfillAuthorityBuilder(ZDO portal, ServerPortalAuthority authority, out ServerPortalAuthority updatedAuthority, string fallbackName = "")
		{
			updatedAuthority = authority;
			if (authority.Builder.IsValid || PublicPortalKinds.IsAdminPortalPrefab(authority.PrefabHash) || !TryCreateRegistryBuilder(portal, out var builder, fallbackName))
			{
				return false;
			}
			updatedAuthority = new ServerPortalAuthority(authority.AccessMode, authority.Owner, authority.AuthorizedClanId, builder, authority.PrefabHash, authority.FavoriteId, authority.RequiredGlobalKey, authority.PublicExpiresAtUtcSeconds);
			return true;
		}

		private static void BackfillBuilderForCreator(long playerId, string steamId, string fallbackName)
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			if (playerId == 0L || ZDOMan.instance == null || !PublicPortalData.TryNormalizeSteamId64(steamId, out string steamId2))
			{
				return;
			}
			int num = 0;
			KeyValuePair<ZDOID, ServerPortalAuthority>[] array = ServerAuthority.ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				KeyValuePair<ZDOID, ServerPortalAuthority> keyValuePair = array[i];
				if (keyValuePair.Value.Builder.IsValid || PublicPortalKinds.IsAdminPortalPrefab(keyValuePair.Value.PrefabHash))
				{
					continue;
				}
				ZDO zDO = ZDOMan.instance.GetZDO(keyValuePair.Key);
				if (zDO == null || !zDO.IsValid() || zDO.GetLong(ZDOVars.s_creator, 0L) != playerId)
				{
					continue;
				}
				string text = zDO.GetString(ZDOVars.s_creatorName, "");
				PortalBuilder builder = SanitizeBuilder(new PortalBuilder(steamId2, string.IsNullOrWhiteSpace(text) ? fallbackName : text, steamId2, playerId, 0L));
				if (builder.IsValid)
				{
					ServerPortalAuthority authority = new ServerPortalAuthority(keyValuePair.Value.AccessMode, keyValuePair.Value.Owner, keyValuePair.Value.AuthorizedClanId, builder, keyValuePair.Value.PrefabHash, keyValuePair.Value.FavoriteId, keyValuePair.Value.RequiredGlobalKey, keyValuePair.Value.PublicExpiresAtUtcSeconds);
					if (TryNormalizeTemporaryPublicAuthority(authority, GetUtcNowSeconds(), out var updatedAuthority, out var _))
					{
						authority = updatedAuthority;
					}
					SetAndPersistServerAuthority(zDO, authority, forceSend: true);
					num++;
				}
			}
			if (num > 0)
			{
				PortalRulesPlugin.PortalRulesLogger.LogInfo((object)($"Attributed {num} existing portal(s) from playerID {playerId} " + "to SteamID64 " + steamId2 + "."));
				MarkServerCatalogDirty();
			}
		}

		private static ServerPortalAuthority CreateAuthorityForNewPortal(ZDO portal)
		{
			if (PublicPortalKinds.IsAdminPortalPrefab(portal.GetPrefab()))
			{
				return CreateAdminPortalAuthority(portal, PublicPortalAccessMode.Public, CreateServerFavoriteId(), ResolveInitialAdminRequiredGlobalKey(portal));
			}
			if (TryCreateServerLocalCreatorlessBlueprintAuthority(portal, out var authority))
			{
				return authority;
			}
			return new ServerPortalAuthority(PublicPortalAccessMode.Personal, new PortalOwner("", ""), "", new PortalBuilder("", ""), portal.GetPrefab(), CreateServerFavoriteId(), "", 0L);
		}

		private static bool TryCreateServerLocalCreatorlessBlueprintAuthority(ZDO portal, out ServerPortalAuthority authority)
		{
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			authority = default(ServerPortalAuthority);
			int prefab = portal.GetPrefab();
			if (_activePortalSync != null || ZDOMan.instance == null || PublicPortalKinds.IsAdminPortalPrefab(prefab) || portal.GetLong(ZDOVars.s_creator, 0L) != 0L || ((ZDOID)(ref portal.m_uid)).UserID != ZDOMan.GetSessionID() || portal.GetInt("PortalRules AuthorityVersion", 0) != 6 || portal.GetInt("PortalRules BuilderAuthorityVersion", 0) != 2 || portal.GetInt("PortalRules AuthorizedPrefabHash", 0) != prefab)
			{
				return false;
			}
			int num = portal.GetInt("PortalRules AccessMode", -1);
			if (num != 2)
			{
				return false;
			}
			PublicPortalAccessMode publicPortalAccessMode = (PublicPortalAccessMode)num;
			authority = new ServerPortalAuthority(publicPortalAccessMode, new PortalOwner("", ""), "", new PortalBuilder("", ""), prefab, CreateServerFavoriteId(), "", 0L);
			PortalRulesPlugin.PortalRulesLogger.LogDebug((object)($"Restored {publicPortalAccessMode} access for server-created creatorless blueprint " + $"portal {portal.m_uid}; copied identity and favorite data were discarded."));
			return true;
		}

		private static string ReadInitialFavoriteId(ZDO portal)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			string text = portal.GetString("PortalRules FavoriteId", "");
			if (PublicPortalData.TryNormalizeFavoriteId(text, out string normalizedFavoriteId) && !ServerPortalsByFavoriteId.ContainsKey(normalizedFavoriteId))
			{
				return normalizedFavoriteId;
			}
			if (!string.IsNullOrWhiteSpace(text))
			{
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)($"Portal {portal.m_uid} had an invalid or duplicate favorite ID; " + "the server assigned a new one."));
			}
			return CreateServerFavoriteId();
		}

		private static string CreateServerFavoriteId()
		{
			string text;
			do
			{
				text = Guid.NewGuid().ToString("N");
			}
			while (ServerPortalsByFavoriteId.ContainsKey(text));
			return text;
		}

		private static bool ZdoMatchesAuthority(ZDO portal, ServerPortalAuthority authority)
		{
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			PortalOwner owner = PublicPortalData.GetOwner(portal);
			PortalBuilder builder = PublicPortalData.GetBuilder(portal);
			bool num = !PublicPortalKinds.IsAdminPortalPrefab(authority.PrefabHash) || (portal.GetLong(ZDOVars.s_creator, 0L) == 0L && string.IsNullOrEmpty(portal.GetString(ZDOVars.s_creatorName, "")));
			bool flag = !PublicPortalKinds.IsAdminPortalPrefab(authority.PrefabHash) || ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer() && portal.GetOwner() == ZDOMan.GetSessionID());
			AdminPortalTagAuthority value;
			bool flag2 = !PublicPortalKinds.IsAdminPortalPrefab(authority.PrefabHash) || (AdminPortalTags.TryGetValue(portal.m_uid, out value) && string.Equals(portal.GetString(ZDOVars.s_tag, ""), value.Tag, StringComparison.Ordinal) && string.IsNullOrEmpty(portal.GetString(ZDOVars.s_tagauthor, "")));
			bool flag3 = string.Equals(portal.GetString("PortalRules RequiredGlobalKey", ""), authority.RequiredGlobalKey, StringComparison.Ordinal);
			bool flag4 = PublicPortalData.GetPublicExpiresAtUtcSeconds(portal) == authority.PublicExpiresAtUtcSeconds;
			if (num && flag && flag2 && flag3 && flag4 && string.Equals(portal.GetString("PortalRules FavoriteId", ""), authority.FavoriteId, StringComparison.Ordinal) && portal.GetInt("PortalRules AuthorityVersion", 0) >= 6 && portal.GetInt("PortalRules BuilderAuthorityVersion", 0) >= 2 && portal.GetInt("PortalRules AccessMode", -1) == (int)authority.AccessMode && string.Equals(owner.Id, authority.Owner.Id, StringComparison.Ordinal) && string.Equals(owner.Name, authority.Owner.Name, StringComparison.Ordinal) && string.Equals(SanitizeClanId(PublicPortalData.GetAuthorizedClanId(portal)), authority.AuthorizedClanId, StringComparison.Ordinal) && string.Equals(builder.AccountId, authority.Builder.AccountId, StringComparison.Ordinal) && string.Equals(builder.Name, authority.Builder.Name, StringComparison.Ordinal) && string.Equals(builder.PlatformId, authority.Builder.PlatformId, StringComparison.Ordinal) && builder.CharacterPlayerId == authority.Builder.CharacterPlayerId && builder.BuildSequence == authority.Builder.BuildSequence && portal.GetInt("PortalRules AuthorizedPrefabHash", 0) == authority.PrefabHash)
			{
				return portal.GetPrefab() == authority.PrefabHash;
			}
			return false;
		}

		private static void WriteAuthorityToZdo(ZDO portal, ServerPortalAuthority authority, bool forceSend)
		{
			//IL_0079: 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)
			portal.SetPrefab(authority.PrefabHash);
			PublicPortalData.SetAccessMode(portal, authority.AccessMode, authority.Owner);
			PublicPortalData.SetAuthorizedClanId(portal, authority.AuthorizedClanId);
			PublicPortalData.SetBuilder(portal, authority.Builder, authority.PrefabHash);
			PublicPortalData.SetFavoriteId(portal, authority.FavoriteId);
			PublicPortalData.SetRequiredGlobalKey(portal, authority.RequiredGlobalKey);
			PublicPortalData.SetPublicExpiresAtUtcSeconds(portal, authority.PublicExpiresAtUtcSeconds);
			if (PublicPortalKinds.IsAdminPortalPrefab(authority.PrefabHash))
			{
				EnsureAdminPortalTagAuthority(portal);
				AdminPortalTagAuthority adminPortalTagAuthority = AdminPortalTags[portal.m_uid];
				portal.Set(ZDOVars.s_creator, 0L);
				portal.Set(ZDOVars.s_creatorName, "");
				portal.Set(ZDOVars.s_tag, adminPortalTagAuthority.Tag);
				portal.Set(ZDOVars.s_tagauthor, "");
				if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
				{
					portal.SetOwner(ZDOMan.GetSessionID());
				}
			}
			portal.Set("PortalRules AuthorityVersion", 6);
			portal.Set("PortalRules BuilderAuthorityVersion", 2);
			if (forceSend && ZDOMan.instance != null)
			{
				ZDOMan.instance.ForceSendZDO(portal.m_uid);
			}
		}

		private static void SetAndPersistServerAuthority(ZDO portal, ServerPortalAuthority authority, bool forceSend)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if (PublicPortalKinds.IsAdminPortalPrefab(portal.GetPrefab()))
			{
				EnsureAdminPortalTagAuthority(portal);
				authority = CreateAdminPortalAuthority(portal, authority.AccessMode, authority.FavoriteId, authority.RequiredGlobalKey);
			}
			authority = SetServerAuthority(portal.m_uid, authority);
			WriteAuthorityToZdo(portal, authority, forceSend);
		}

		private static ServerPortalAuthority CreateAdminPortalAuthority(ZDO portal, PublicPortalAccessMode? requestedMode = null, string? favoriteId = null, string? requiredGlobalKey = null)
		{
			PublicPortalAccessMode publicPortalAccessMode = (PublicPortalAccessMode)(((int?)requestedMode) ?? portal.GetInt("PortalRules AccessMode", 2));
			if (!IsAllowedAdminPortalMode(publicPortalAccessMode))
			{
				publicPortalAccessMode = PublicPortalAccessMode.Public;
			}
			string normalizedFavoriteId;
			return new ServerPortalAuthority(publicPortalAccessMode, new PortalOwner("", ""), "", new PortalBuilder("", ""), portal.GetPrefab(), PublicPortalData.TryNormalizeFavoriteId(favoriteId, out normalizedFavoriteId) ? normalizedFavoriteId : CreateServerFavoriteId(), requiredGlobalKey ?? "", 0L);
		}

		private static string ResolveInitialAdminRequiredGlobalKey(ZDO portal)
		{
			//IL_0062: 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)
			string text = default(string);
			if (portal.GetString("PortalRules RequiredGlobalKey", ref text))
			{
				if (PublicPortalData.TryNormalizeRequiredGlobalKey(text, out string normalized, out RequiredGlobalKeyValidationFailure failure))
				{
					return normalized;
				}
				PortalRulesPlugin.PortalRulesLogger.LogError((object)($"Admin portal {portal.m_uid} has an invalid explicit Required GlobalKey " + $"({failure}); preserving it so access fails closed."));
				return (text ?? "").Trim();
			}
			if (!AdminPortalBiomeDefaults.TryResolve(portal.GetPosition(), out string requiredGlobalKey))
			{
				return "";
			}
			return requiredGlobalKey;
		}

		private static bool CanInitializeAdminPortalAuthority(ZDO portal)
		{
			string text = default(string);
			if (!portal.GetString("PortalRules RequiredGlobalKey", ref text))
			{
				return AdminPortalBiomeDefaults.HasValidSnapshot;
			}
			return true;
		}

		private static bool IsAllowedAdminPortalMode(PublicPortalAccessMode mode)
		{
			if ((uint)(mode - 1) <= 1u || mode == PublicPortalAccessMode.Tagged)
			{
				return true;
			}
			return false;
		}

		private static long GetUtcNowSeconds()
		{
			return DateTimeOffset.UtcNow.ToUnixTimeSeconds();
		}

		private static long CreateTemporaryPublicExpirationUtcSeconds(PublicPortalAccessMode accessMode, PortalBuilder builder, int prefabHash)
		{
			return CreateTemporaryPublicExpirationUtcSeconds(accessMode, builder, prefabHash, GetUtcNowSeconds());
		}

		private static long CreateTemporaryPublicExpirationUtcSeconds(PublicPortalAccessMode accessMode, PortalBuilder builder, int prefabHash, long nowUtcSeconds)
		{
			int value = PublicPortalConfig.PublicAccessDurationSeconds.Value;
			if (accessMode != PublicPortalAccessMode.Public || !builder.IsValid || PublicPortalKinds.IsAdminPortalPrefab(prefabHash) || value <= 0)
			{
				return 0L;
			}
			return Math.Min(253402300799L, nowUtcSeconds + value);
		}

		private static bool IsTemporaryPublicAccessExpired(ServerPortalAuthority authority, long nowUtcSeconds)
		{
			if (PublicPortalConfig.PublicAccessDurationSeconds.Value > 0 && authority.AccessMode == PublicPortalAccessMode.Public && authority.Builder.IsValid && !PublicPortalKinds.IsAdminPortalPrefab(authority.PrefabHash))
			{
				if (authority.PublicExpiresAtUtcSeconds != 0L)
				{
					return authority.PublicExpiresAtUtcSeconds <= nowUtcSeconds;
				}
				return true;
			}
			return false;
		}

		private static bool TryNormalizeTemporaryPublicAuthority(ServerPortalAuthority authority, long nowUtcSeconds, out ServerPortalAuthority updatedAuthority, out bool revertedToPersonal)
		{
			updatedAuthority = authority;
			revertedToPersonal = false;
			if (authority.AccessMode != PublicPortalAccessMode.Public || !authority.Builder.IsValid || PublicPortalKinds.IsAdminPortalPrefab(authority.PrefabHash) || PublicPortalConfig.PublicAccessDurationSeconds.Value <= 0)
			{
				if (authority.PublicExpiresAtUtcSeconds == 0L)
				{
					return false;
				}
				updatedAuthority = new ServerPortalAuthority(authority.AccessMode, authority.Owner, authority.AuthorizedClanId, authority.Builder, authority.PrefabHash, authority.FavoriteId, authority.RequiredGlobalKey, 0L);
				return true;
			}
			if (!IsTemporaryPublicAccessExpired(authority, nowUtcSeconds))
			{
				return false;
			}
			updatedAuthority = new ServerPortalAuthority(PublicPortalAccessMode.Personal, new PortalOwner(authority.Builder.AccountId, authority.Builder.Name), "", authority.Builder, authority.PrefabHash, authority.FavoriteId, authority.RequiredGlobalKey, 0L);
			revertedToPersonal = true;
			return true;
		}

		private static bool TryNormalizeDisabledInviteAuthority(ServerPortalAuthority authority, out ServerPortalAuthority updatedAuthority)
		{
			updatedAuthority = authority;
			if (!PortalAccountStore.HasValidOverrideSnapshot || authority.AccessMode != PublicPortalAccessMode.Invite || !authority.Builder.IsValid || PublicPortalKinds.IsAdminPortalPrefab(authority.PrefabHash) || PortalAccountStore.GetEffectiveInvitePortalLimit(authority.Builder.AccountId, PublicPortalConfig.MaxInvitePortalsPerAccount.Value) != 0)
			{
				return false;
			}
			updatedAuthority = new ServerPortalAuthority(PublicPortalAccessMode.Personal, new PortalOwner(authority.Builder.AccountId, authority.Builder.Name), "", authority.Builder, authority.PrefabHash, authority.FavoriteId, authority.RequiredGlobalKey, 0L);
			return true;
		}

		private static void EnsureAdminPortalTagAuthority(ZDO portal)
		{
			//IL_0006: 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 (!AdminPortalTags.ContainsKey(portal.m_uid))
			{
				AdminPortalTags.Add(portal.m_uid, new AdminPortalTagAuthority(Truncate(portal.GetString(ZDOVars.s_tag, ""), 10)));
			}
		}

		private static void BroadcastSnapshot()
		{
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				return;
			}
			ZNetPeer[] array = ZNet.instance.GetPeers().ToArray();
			foreach (ZNetPeer val in array)
			{
				if (val.IsReady() && val.m_rpc != null)
				{
					SendSnapshot(val.m_rpc, val);
				}
			}
		}

		private static void BroadcastChangedViews()
		{
			if ((Object)(object)ZNet.instance == (Object)null || !_hasSnapshot)
			{
				return;
			}
			ZNetPeer[] array = ZNet.instance.GetPeers().ToArray();
			foreach (ZNetPeer val in array)
			{
				if (val.IsReady() && val.m_rpc != null)
				{
					RecipientContext recipientContext = CreateRecipientContext(val);
					ulong fingerprint;
					List<PublicPortalCatalogEntry> visibleEntries = BuildRecipientEntries(recipientContext, out fingerprint);
					if (!LastSentViews.TryGetValue(val.m_rpc, out var value) || !value.MatchesView(_serverRevision, recipientContext.OwnerId, recipientContext.IsAdmin, fingerprint) || (!value.Acknowledged && Time.realtimeSinceStartup - value.LastSentAt >= 30f))
					{
						SendSnapshot(val.m_rpc, val, recipientContext, visibleEntries, fingerprint);
					}
				}
			}
		}

		private static void SendSnapshot(ZRpc rpc, ZNetPeer peer)
		{
			if (!rpc.IsConnected())
			{
				LastServerRequestAt.Remove(rpc);
				LastSentViews.Remove(rpc);
			}
			else
			{
				RecipientContext recipient = CreateRecipientContext(peer);
				ulong fingerprint;
				List<PublicPortalCatalogEntry> visibleEntries = BuildRecipientEntries(recipient, out fingerprint);
				SendSnapshot(rpc, peer, recipient, visibleEntries, fingerprint);
			}
		}

		private static void SendSnapshot(ZRpc rpc, ZNetPeer peer, RecipientContext recipient, List<PublicPortalCatalogEntry> visibleEntries, ulong recipientViewFingerprint)
		{
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Expected O, but got Unknown
			if (!rpc.IsConnected())
			{
				LastServerRequestAt.Remove(rpc);
				LastSentViews.Remove(rpc);
				return;
			}
			SentViewState value;
			long num = ((LastSentViews.TryGetValue(rpc, out value) && value.MatchesView(_serverRevision, recipient.OwnerId, recipient.IsAdmin, recipientViewFingerprint)) ? value.ViewToken : NextViewToken());
			int num2 = Math.Max(1, (visibleEntries.Count + 96 - 1) / 96);
			long utcNowSeconds = GetUtcNowSeconds();
			for (int i = 0; i < num2; i++)
			{
				int num3 = i * 96;
				int num4 = Math.Min(96, visibleEntries.Count - num3);
				ZPackage val = new ZPackage();
				val.Write((byte)7);
				val.Write(_serverRevision);
				val.Write(num);
				val.Write(i);
				val.Write(num2);
				val.Write(visibleEntries.Count);
				val.Write(recipient.OwnerId);
				val.Write(recipient.IsAdmin);
				val.Write(utcNowSeconds);
				val.Write(num4);
				for (int j = 0; j < num4; j++)
				{
					WriteCatalogEntry(val, visibleEntries[num3 + j]);
				}
				rpc.Invoke("sighsorry.PortalRules.CatalogSnapshot.v7", new object[1] { val });
			}
			LastSentViews[rpc] = new SentViewState(_serverRevision, recipient.OwnerId, recipient.IsAdmin, recipientViewFingerprint, num, acknowledged: false, Time.realtimeSinceStartup);
			PublicPortalServerPolicy.SendQuotaState(peer, force: true);
		}

		private static void AcknowledgeSnapshot(int revision, long viewToken)
		{
			if (!((Object)(object)ZNet.instance == (Object)null) && !ZNet.instance.IsServer())
			{
				ZRpc serverRPC = ZNet.instance.GetServerRPC();
				if (serverRPC != null && serverRPC.IsConnected())
				{
					serverRPC.Invoke("sighsorry.PortalRules.CatalogRequest.v7", new object[2] { revision, viewToken });
				}
			}
		}

		private static long NextViewToken()
		{
			_nextViewToken++;
			if (_nextViewToken == 0L)
			{
				_nextViewToken++;
			}
			return _nextViewToken;
		}

		private static RecipientContext CreateRecipientContext(ZNetPeer peer)
		{
			PortalOwner owner2;
			PortalOwner owner = (PublicPortalData.TryGetPeerOwner(peer, out owner2) ? owner2 : new PortalOwner("", ""));
			bool isAdmin = (Object)(object)ZNet.instance != (Object)null && PublicPortalData.IsPeerAdmin(ZNet.instance, peer);
			return CreateRecipientContext(owner, isAdmin, ResolvePeerMembership(peer), peer);
		}

		private static RecipientContext CreateRecipientContext(PortalOwner owner, bool isAdmin, PortalClanMembership clanMembership, ZNetPeer? peer = null)
		{
			return new RecipientContext(SanitizeOwner(owner).Id, isAdmin, clanMembership, peer);
		}

		private static bool TryCreateRemoteAuthorizationContext(ZNetPeer? peer, out RecipientContext recipient, out Vector3 playerPosition)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			recipient = null;
			playerPosition = Vector3.positiveInfinity;
			if (!PublicPortalData.TryGetPeerOwner(peer, out var owner) || !PublicPortalData.TryGetAuthenticatedPeerCharacterPosition(peer, out playerPosition))
			{
				return false;
			}
			recipient = CreateRecipientContext(owner, PublicPortalData.IsPeerAdmin(ZNet.instance, peer), ResolvePeerMembership(peer), peer);
			return true;
		}

		private static void CreateLocalAuthorizationContext(out RecipientContext recipient, out Vector3 playerPosition)
		{
			//IL_001f: 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_0024: Unknown result type (might be due to invalid IL or missing references)
			playerPosition = (((Object)(object)Player.m_localPlayer != (Object)null) ? ((Component)Player.m_localPlayer).transform.position : Vector3.positiveInfinity);
			recipient = CreateRecipientContext(PublicPortalData.LocalOwner(), PortalRulesPlugin.IsAdmin, ResolveLocalMembership());
		}

		private static void RefreshLocalRecipientView(bool catalogChanged)
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				ResetLocalRecipientViewState();
				return;
			}
			RecipientContext recipientContext = CreateRecipientContext(PublicPortalData.LocalOwner(), PortalRulesPlugin.IsAdmin, ResolveLocalMembership());
			ulong fingerprint;
			List<PublicPortalCatalogEntry> received = BuildRecipientEntries(recipientContext, out fingerprint);
			bool flag = !_localRecipientViewInitialized || !string.Equals(_localRecipientOwnerId, recipientContext.OwnerId, StringComparison.Ordinal) || _localRecipientIsAdmin != recipientContext.IsAdmin || _localRecipientViewFingerprint != fingerprint;
			_localRecipientViewInitialized = true;
			_localRecipientOwnerId = recipientContext.OwnerId;
			_localRecipientIsAdmin = recipientContext.IsAdmin;
			_localRecipientViewFingerprint = fingerprint;
			if (catalogChanged || flag)
			{
				ApplyLocalClientEntries(received, forceUpdate: true);
			}
		}

		private static void ResetLocalRecipientViewState()
		{
			_localRecipientViewInitialized = false;
			_localRecipientOwnerId = "";
			_localRecipientIsAdmin = false;
			_localRecipientViewFingerprint = 0uL;
		}

		private static PortalClanMembership ResolvePeerMembership(ZNetPeer? peer)
		{
			if (!ClanPortalAccess.TryResolvePeerMembership(peer, out var membership))
			{
				return default(PortalClanMembership);
			}
			return membership;
		}

		private static PortalClanMembership ResolveLocalMembership()
		{
			if (!ClanPortalAccess.TryResolveLocalMembership(out var membership))
			{
				return default(PortalClanMembership);
			}
			return membership;
		}

		private static bool ShouldSendEntry(PublicPortalCatalogEntry entry, RecipientContext recipient)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			if (ServerAuthority.TryGetValue(entry.Id, out var value))
			{
				return CanRecipientUseAuthority(value, recipient);
			}
			return false;
		}

		private static void ApplyModeDisplayMetadata(List<PublicPortalCatalogEntry> entries)
		{
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<ZDOID, (int, int, int)> dictionary = new Dictionary<ZDOID, (int, int, int)>();
			foreach (IGrouping<string, KeyValuePair<ZDOID, ServerPortalAuthority>> item2 in ServerAuthority.Where((KeyValuePair<ZDOID, ServerPortalAuthority> pair) => !PendingRemovalIds.Contains(pair.Key) && pair.Value.AccessMode == PublicPortalAccessMode.Invite && pair.Value.Builder.IsValid && !PublicPortalKinds.IsAdminPortalPrefab(pair.Value.PrefabHash)).GroupBy<KeyValuePair<ZDOID, ServerPortalAuthority>, string>((KeyValuePair<ZDOID, ServerPortalAuthority> pair) => pair.Value.Builder.AccountId, StringComparer.Ordinal))
			{
				List<KeyValuePair<ZDOID, ServerPortalAuthority>> list = OrderAuthorityByBuildSequence(item2);
				int effectiveInvitePortalLimit = PortalAccountStore.GetEffectiveInvitePortalLimit(item2.Key, PublicPortalConfig.MaxInvitePortalsPerAccount.Value);
				for (int num = 0; num < list.Count; num++)
				{
					dictionary[list[num].Key] = (num + 1, list.Count, effectiveInvitePortalLimit);
				}
			}
			int item = Math.Max(-1, Math.Min(10000, PublicPortalConfig.MaxClanPortalsPerClan.Value));
			foreach (IGrouping<string, KeyValuePair<ZDOID, ServerPortalAuthority>> item3 in ServerAuthority.Where((KeyValuePair<ZDOID, ServerPortalAuthority> pair) => !PendingRemovalIds.Contains(pair.Key) && pair.Value.AccessMode == PublicPortalAccessMode.Clan && pair.Value.Builder.IsValid && !string.IsNullOrWhiteSpace(pair.Value.AuthorizedClanId) && !PublicPortalKinds.IsAdminPortalPrefab(pair.Value.PrefabHash)).GroupBy<KeyValuePair<ZDOID, ServerPortalAuthority>, string>((KeyValuePair<ZDOID, ServerPortalAuthority> pair) => pair.Value.AuthorizedClanId, StringComparer.Ordinal))
			{
				List<KeyValuePair<ZDOID, ServerPortalAuthority>> list2 = OrderAuthorityByBuildSequence(item3);
				for (int num2 = 0; num2 < list2.Count; num2++)
				{
					dictionary[list2[num2].Key] = (num2 + 1, list2.Count, item);
				}
			}
			for (int num3 = 0; num3 < entries.Count; num3++)
			{
				PublicPortalCatalogEntry publicPortalCatalogEntry = entries[num3];
				if (dictionary.TryGetValue(publicPortalCatalogEntry.Id, out var value))
				{
					entries[num3] = publicPortalCatalogEntry.WithDisplayMetadata(0, 0, value.Item1, value.Item2, value.Item3, 0L, 0L);
				}
			}
		}

		private static List<KeyValuePair<ZDOID, ServerPortalAuthority>> OrderAuthorityByBuildSequence(IEnumerable<KeyValuePair<ZDOID, ServerPortalAuthority>> authorities)
		{
			return authorities.OrderBy((KeyValuePair<ZDOID, ServerPortalAuthority> pair) => (pair.Value.Builder.BuildSequence <= 0) ? long.MaxValue : pair.Value.Builder.BuildSequence).ThenBy<KeyValuePair<ZDOID, ServerPortalAuthority>, string>((KeyValuePair<ZDOID, ServerPortalAuthority> pair) => pair.Value.FavoriteId, StringComparer.Ordinal).ThenBy((KeyValuePair<ZDOID, ServerPortalAuthority> pair) => pair.Key)
				.ToList();
		}

		private static List<PublicPortalCatalogEntry> BuildRecipientEntries(RecipientContext recipient)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<ZDOID, int> dictionary = new Dictionary<ZDOID, int>();
			int num = 0;
			if (PublicPortalData.TryNormalizeSteamId64(recipient.OwnerId, out string recipientAccountId))
			{
				List<KeyValuePair<ZDOID, ServerPortalAuthority>> list = OrderAuthorityByBuildSequence(ServerAuthority.Where((KeyValuePair<ZDOID, ServerPortalAuthority> pair) => !PendingRemovalIds.Contains(pair.Key) && pair.Value.Builder.IsValid && string.Equals(pair.Value.Builder.AccountId, recipientAccountId, StringComparison.Ordinal) && PublicPortalServerPolicy.IsCountedPortalPrefab(pair.Value.PrefabHash)));
				for (int num2 = 0; num2 < list.Count; num2++)
				{
					dictionary[list[num2].Key] = num2 + 1;
				}
				num = (PublicPortalConfig.EnableAccountPortalLimit.Value.IsOff() ? (-1) : PortalAccountStore.GetEffectivePortalLimit(recipientAccountId, PublicPortalConfig.MaxPortalsPerAccount.Value));
			}
			List<PublicPortalCatalogEntry> list2 = new List<PublicPortalCatalogEntry>();
			foreach (PublicPortalCatalogEntry serverEntry in ServerEntries)
			{
				if (ShouldSendEntry(serverEntry, recipient))
				{
					int value;
					int num3 = (dictionary.TryGetValue(serverEntry.Id, out value) ? value : 0);
					long departureUntilUtc = 0L;
					long arrivalUntilUtc = 0L;
					if (serverEntry.AccessMode == PublicPortalAccessMode.Invite && !string.IsNullOrWhiteSpace(recipient.OwnerId))
					{
						InviteTravelCooldownStore.GetServerDeadlines(recipient.OwnerId, serverEntry.FavoriteId, out departureUntilUtc, out arrivalUntilUtc);
					}
					list2.Add(serverEntry.WithDisplayMetadata(num3, (num3 > 0) ? num : 0, serverEntry.ModeOrdinal, serverEntry.ModeCurrent, serverEntry.ModeLimit, departureUntilUtc, arrivalUntilUtc));
				}
			}
			return list2;
		}

		private static List<PublicPortalCatalogEntry> BuildRecipientEntries(RecipientContext recipient, out ulong fingerprint)
		{
			List<PublicPortalCatalogEntry> list = BuildRecipientEntries(recipient);
			fingerprint = ComputeRecipientViewFingerprint(list);
			return list;
		}

		private static void RefreshLocalClientEntries(bool forceUpdate)
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				if (ClientEntries.Count > 0)
				{
					ClientEntries.Clear();
					ClientIndex.Clear();
					if (forceUpdate)
					{
						PublicPortalCatalog.Updated?.Invoke();
					}
				}
			}
			else
			{
				RecipientContext recipientContext = CreateRecipientContext(PublicPortalData.LocalOwner(), PortalRulesPlugin.IsAdmin, ResolveLocalMembership());
				ulong fingerprint;
				List<PublicPortalCatalogEntry> received = BuildRecipientEntries(recipientContext, out fingerprint);
				_localRecipientViewInitialized = true;
				_localRecipientOwnerId = recipientContext.OwnerId;
				_localRecipientIsAdmin = recipientContext.IsAdmin;
				_localRecipientViewFingerprint = fingerprint;
				ApplyLocalClientEntries(received, forceUpdate);
			}
		}

		private static void ApplyLocalClientEntries(List<PublicPortalCatalogEntry> received, bool forceUpdate)
		{
			bool num = !SnapshotsMatch(ClientEntries, received);
			_clientRevision = _serverRevision;
			if (num || forceUpdate)
			{
				ClientEntries.Clear();
				ClientEntries.AddRange(received);
				RebuildClientIndex();
				PublicPortalCatalog.Updated?.Invoke();
			}
		}

		private static ulong ComputeRecipientViewFingerprint(IReadOnlyList<PublicPortalCatalogEntry> entries)
		{
			ulong fingerprint = 14695981039346656037uL;
			HashFingerprintInt(ref fingerprint, entries.Count, 1099511628211uL);
			foreach (PublicPortalCatalogEntry entry in entries)
			{
				HashFingerprintInt(ref fingerprint, entry.FavoriteId.Length, 1099511628211uL);
				string favoriteId = entry.FavoriteId;
				foreach (char c in favoriteId)
				{
					fingerprint ^= c;
					fingerprint *= 1099511628211L;
				}
				HashFingerprintInt(ref fingerprint, (int)entry.AccessMode, 1099511628211uL);
				HashFingerprintInt(ref fingerprint, entry.AllowsAllItems ? 1 : 0, 1099511628211uL);
				HashFingerprintInt(ref fingerprint, entry.MyPortalOrdinal, 1099511628211uL);
				HashFingerprintInt(ref fingerprint, entry.MyPortalLimit, 1099511628211uL);
				HashFingerprintInt(ref fingerprint, entry.ModeOrdinal, 1099511628211uL);
				HashFingerprintInt(ref fingerprint, entry.ModeCurrent, 1099511628211uL);
				HashFingerprintInt(ref fingerprint, entry.ModeLimit, 1099511628211uL);
				HashFingerprintLong(ref fingerprint, entry.InviteDepartureCooldownUntilUtc, 1099511628211uL);
				HashFingerprintLong(ref fingerprint, entry.InviteArrivalCooldownUntilUtc, 1099511628211uL);
			}
			return fingerprint;
		}

		private static void HashFingerprintInt(ref ulong fingerprint, int value, ulong prime)
		{
			HashFingerprintLong(ref fingerprint, value, prime);
		}

		private static void HashFingerprintLong(ref ulong fingerprint, long value, ulong prime)
		{
			ulong num = (ulong)value;
			for (int i = 0; i < 8; i++)
			{
				fingerprint ^= (byte)num;
				fingerprint *= prime;
				num >>= 8;
			}
		}

		private static void ResetSessionState()
		{
			_sessionGeneration++;
			_serverLoopGame = null;
			_serverRevision = 0;
			_clientRevision = -1;
			_clientViewToken = 0L;
			_nextViewToken = 0L;
			_nextBuildSequence = 0L;
			_lastClientRequestAt = -100f;
			_nextIdentityReconcileAt = -100f;
			_authorityBackfilled = false;
			_hasSnapshot = false;
			_worldLoaded = false;
			_serverCatalogDirty = false;
			_serverDirtyFlushScheduled = false;
			ResetLocalRecipientViewState();
			_activePortalSync = null;
			_activeLocalPlacementBuilder = new PortalBuilder("", "");
			_pendingLocalPlacementPortalIds = null;
			ServerEntries.Clear();
			ClientEntries.Clear();
			ClientIndex.Clear();
			ServerAuthority.Clear();
			ServerPortalsByFavoriteId.Clear();
			AdminPortalTags.Clear();
			ServerPortalsByBuilder.Clear();
			InitialWorldPortalIds.Clear();
			PendingRemovalIds.Clear();
			LastServerRequestAt.Clear();
			LastSentViews.Clear();
			_clientServerUtcAtSync = 0L;
			_clientServerClockTimestamp = 0L;
			PublicPortalData.SetServerAssignedOwnerId("");
			PublicPortalData.SetServerAssignedIsAdmin(isAdmin: false);
			ResetPendingSnapshot();
		}

		private static void ResetPendingSnapshot()
		{
			_pendingSnapshot = null;
		}

		private static void RebuildClientIndex()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			ClientIndex.Clear();
			foreach (PublicPortalCatalogEntry clientEntry in ClientEntries)
			{
				ClientIndex[clientEntry.Id] = clientEntry;
			}
		}

		private static bool TryAuthorizeTeleport(RecipientContext recipient, Vector3 playerPosition, ZDOID sourcePortalId, ZDOID targetPortalId, bool requireConnectedPortal, string reservationId, out PortalTravelAuthorization authorization, out PortalTravelDenial denial)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: 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_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: 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_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: 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_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			authorization = default(PortalTravelAuthorization);
			denial = new PortalTravelDenial(PortalTravelDenialCode.Denied, "", 0L, 0L);
			if ((!requireConnectedPortal && PublicPortalConfig.EnablePortalMap.Value.IsOff()) || ((ZDOID)(ref targetPortalId)).IsNone() || sourcePortalId == targetPortalId)
			{
				return false;
			}
			if (!TryAuthorizePortalSource(recipient, playerPosition, sourcePortalId, requireConnectedPortal, out ZDO sourcePortal, out ServerPortalAuthority sourceAuthority, out denial))
			{
				return false;
			}
			Vector3 position = sourcePortal.GetPosition();
			if (!TryGetUsablePortal(targetPortalId, recipient, source: false, out ZDO portal, out denial))
			{
				return false;
			}
			if (!ServerAuthority.TryGetValue(targetPortalId, out var value))
			{
				denial = new PortalTravelDenial(PortalTravelDenialCode.DestinationUnavailable, "", 0L, 0L);
				return false;
			}
			bool flag = value.AccessMode == PublicPortalAccessMode.Tagged;
			if (requireConnectedPortal && PublicPortalConfig.EnablePortalMap.Value.IsOn() && !flag)
			{
				denial = new PortalTravelDenial(PortalTravelDenialCode.DestinationNotTagged, "", 0L, 0L);
				return false;
			}
			if (requireConnectedPortal && (sourcePortal.GetConnectionZDOID((ConnectionType)1) != targetPortalId || portal.GetConnectionZDOID((ConnectionType)1) != sourcePortalId))
			{
				denial = new PortalTravelDenial(PortalTravelDenialCode.ConnectionChanged, "", 0L, 0L);
				return false;
			}
			Vector3 position2 = portal.GetPosition();
			Quaternion rotation = portal.GetRotation();
			if (!IsSafePortalPosition(position2) || !TryNormalizePortalRotation(rotation, out var normalized))
			{
				position2 = Vector3.zero;
				rotation = Quaternion.identity;
				denial = new PortalTravelDenial(PortalTravelDenialCode.DestinationPositionInvalid, "", 0L, 0L);
				return false;
			}
			rotation = normalized;
			int coinCost = PublicPortalTravelCost.CalculateCost(sourceAuthority.PrefabHash, sourceAuthority.AccessMode, PublicPortalKinds.PrefabAllowsAllItems(sourceAuthority.PrefabHash), position, value.PrefabHash, value.AccessMode, position2);
			bool usesInviteAsSource = sourceAuthority.AccessMode == PublicPortalAccessMode.Invite;
			bool usesInviteAsDestination = value.AccessMode == PublicPortalAccessMode.Invite;
			if (!InviteTravelCooldownStore.TryReserve(reservationId, recipient.OwnerId, usesInviteAsSource, sourceAuthority.FavoriteId, usesInviteAsDestination, value.FavoriteId, out var reservation, out var failure, out var departureRemaining, out var arrivalRemaining))
			{
				position2 = Vector3.zero;
				rotation = Quaternion.identity;
				coinCost = 0;
				denial = CreateInviteCooldownDenial(failure, departureRemaining, arrivalRemaining);
				return false;
			}
			authorization = new PortalTravelAuthorization(position2, rotation, coinCost, recipient.OwnerId, sourceAuthority.FavoriteId, value.FavoriteId, usesInviteAsSource, usesInviteAsDestination, reservation);
			denial = PortalTravelDenial.None;
			return true;
		}

		private static bool TryAuthorizePortalSource(RecipientContext recipient, Vector3 playerPosition, ZDOID sourcePortalId, bool requireConnectedPortal, out ZDO sourcePortal, out ServerPortalAuthority sourceAuthority, out PortalTravelDenial denial)
		{
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			sourcePortal = null;
			sourceAuthority = default(ServerPortalAuthority);
			denial = new PortalTravelDenial(PortalTravelDenialCode.Denied, "", 0L, 0L);
			if (string.IsNullOrWhiteSpace(recipient.OwnerId) || ((ZDOID)(ref sourcePortalId)).IsNone() || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || ZDOMan.instance == null)
			{
				return false;
			}
			if ((Object)(object)ZoneSystem.instance == (Object)null)
			{
				denial = new PortalTravelDenial(PortalTravelDenialCode.NotReady, "", 0L, 0L);
				return false;
			}
			if (ZoneSystem.instance.GetGlobalKey((GlobalKeys)27))
			{
				denial = new PortalTravelDenial(PortalTravelDenialCode.PortalsBlocked, "", 0L, 0L);
				return false;
			}
			if (ZoneSystem.instance.GetGlobalKey((GlobalKeys)28))
			{
				RandEventSystem instance = RandEventSystem.instance;
				float num = default(float);
				if (((instance != null) ? instance.GetBossEvent() : null) != null || (ZoneSystem.instance.GetGlobalKey((GlobalKeys)38, ref num) && num > 0f))
				{
					denial = new PortalTravelDenial(PortalTravelDenialCode.BossBlocked, "", 0L, 0L);
					return false;
				}
			}
			if (!TryGetUsablePortal(sourcePortalId, recipient, source: true, out sourcePortal, out denial))
			{
				return false;
			}
			if (!ServerAuthority.TryGetValue(sourcePortalId, out sourceAuthority))
			{
				denial = new PortalTravelDenial(PortalTravelDenialCode.SourceUnavailable, "", 0L, 0L);
				return false;
			}
			bool flag = sourceAuthority.AccessMode == PublicPortalAccessMode.Tagged;
			if (requireConnectedPortal)
			{
				if (PublicPortalConfig.EnablePortalMap.Value.IsOn() && !flag)
				{
					denial = new PortalTravelDenial(PortalTravelDenialCode.SourceNotTagged, "", 0L, 0L);
					return false;
				}
			}
			else if (flag)
			{
				denial = new PortalTravelDenial(PortalTravelDenialCode.TaggedRequiresConnectedDestination, "", 0L, 0L);
				return false;
			}
			Vector3 position = sourcePortal.GetPosition();
			if (!IsFinite(playerPosition) || !IsSafePortalPosition(position) || Vector3.Distance(playerPosition, position) > 15f)
			{
				denial = new PortalTravelDenial(PortalTravelDenialCode.SourceTooFar, "", 0L, 0L);
				return false;
			}
			denial = PortalTravelDenial.None;
			return true;
		}

		private static PortalTravelDenial CreateInviteCooldownDenial(InviteTravelCooldownFailure failure, long departureRemaining, long arrivalRemaining)
		{
			return failure switch
			{
				InviteTravelCooldownFailure.DataUnavailable => new PortalTravelDenial(PortalTravelDenialCode.InviteCooldownDataUnavailable, "", 0L, 0L), 
				InviteTravelCooldownFailure.StorageUnavailable => new PortalTravelDenial(PortalTravelDenialCode.InviteCooldownStorageUnavailable, "", 0L, 0L), 
				InviteTravelCooldownFailure.Active => new PortalTravelDenial(PortalTravelDenialCode.InviteCooldownActive, "", Math.Max(0L, departureRemaining), Math.Max(0L, arrivalRemaining)), 
				InviteTravelCooldownFailure.AccountCapacityReached => new PortalTravelDenial(PortalTravelDenialCode.InviteCooldownAccountCapacityReached, "", 0L, 0L), 
				InviteTravelCooldownFailure.PortalCapacityReached => new PortalTravelDenial(PortalTravelDenialCode.InviteCooldownPortalCapacityReached, "", 0L, 0L), 
				InviteTravelCooldownFailure.FileCapacityReached => new PortalTravelDenial(PortalTravelDenialCode.InviteCooldownFileCapacityReached, "", 0L, 0L), 
				InviteTravelCooldownFailure.SaveFailed => new PortalTravelDenial(PortalTravelDenialCode.InviteCooldownSaveFailed, "", 0L, 0L), 
				InviteTravelCooldownFailure.ReservationConflict => new PortalTravelDenial(PortalTravelDenialCode.RequestRateLimited, "", 0L, 0L), 
				_ => new PortalTravelDenial(PortalTravelDenialCode.InviteCooldownDataUnavailable, "", 0L, 0L), 
			};
		}

		internal static void RefreshCommittedInviteCooldownView(ZNetPeer? peer)
		{
			if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer())
			{
				RecipientContext recipient;
				if (peer != null)
				{
					recipient = CreateRecipientContext(peer);
				}
				else
				{
					CreateLocalAuthorizationContext(out recipient, out Vector3 _);
				}
				RefreshRecipientCooldownView(recipient);
			}
		}

		private static void RefreshRecipientCooldownView(RecipientContext recipient)
		{
			if (recipient.Peer != null)
			{
				if (recipient.Peer.m_rpc != null && recipient.Peer.m_rpc.IsConnected())
				{
					SendSnapshot(recipient.Peer.m_rpc, recipient.Peer);
				}
			}
			else
			{
				RefreshLocalClientEntries(forceUpdate: true);
			}
		}

		internal static long GetEstimatedServerUtcNowSeconds()
		{
			if ((Object)(object)ZNet.instance == (Object)null || ZNet.instance.IsServer() || _clientServerUtcAtSync <= 0 || _clientServerClockTimestamp <= 0)
			{
				return GetUtcNowSeconds();
			}
			long num = Stopwatch.GetTimestamp() - _clientServerClockTimestamp;
			if (num <= 0)
			{
				return _clientServerUtcAtSync;
			}
			long num2 = (long)((double)num / (double)Stopwatch.Frequency);
			if (_clientServerUtcAtSync <= 253402300799L - num2)
			{
				return _clientServerUtcAtSync + num2;
			}
			return 253402300799L;
		}

		private static void SynchronizeClientServerClock(long serverUtcAtSend, long firstChunkReceivedTimestamp)
		{
			_clientServerUtcAtSync = serverUtcAtSend;
			_clientServerClockTimestamp = ((firstChunkReceivedTimestamp > 0) ? firstChunkReceivedTimestamp : Stopwatch.GetTimestamp());
		}

		private static bool TryGetUsablePortal(ZDOID portalId, RecipientContext recipient, bool source, out ZDO portal, out PortalTravelDenial denial)
		{
			//IL_0024: 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_0049: Unknown result type (might be due to invalid IL or missing references)
			portal = null;
			denial = new PortalTravelDenial(source ? PortalTravelDenialCode.SourceUnavailable : PortalTravelDenialCode.DestinationUnavailable, "", 0L, 0L);
			if (PendingRemovalIds.Contains(portalId) || !ServerAuthority.TryGetValue(portalId, out var value) || ZDOMan.instance == null)
			{
				return false;
			}
			ZDO zDO = ZDOMan.instance.GetZDO(portalId);
			if (zDO == null || !zDO.IsValid())
			{
				return false;
			}
			if (!ZdoMatchesAuthority(zDO, value))
			{
				WriteAuthorityToZdo(zDO, value, forceSend: true);
			}
			if (!PublicPortalKinds.IsHandledPortal(zDO))
			{
				return false;
			}
			if (!CanRecipientUseBaseAuthority(value, recipient))
			{
				denial = new PortalTravelDenial(source ? PortalTravelDenialCode.SourceAccessDenied : PortalTravelDenialCode.DestinationAccessDenied, "", 0L, 0L);
				return false;
			}
			if (!TryCheckRecipientRequiredGlobalKey(value, recipient, out denial))
			{
				return false;
			}
			portal = zDO;
			denial = PortalTravelDenial.None;
			return true;
		}

		private static bool CanRecipientUseAuthority(ServerPortalAuthority authority, RecipientContext recipient)
		{
			PortalTravelDenial denial;
			if (CanRecipientUseBaseAuthority(authority, recipient))
			{
				return TryCheckRecipientRequiredGlobalKey(authority, recipient, out denial);
			}
			return false;
		}

		private static bool CanRecipientUseBaseAuthority(ServerPortalAuthority authority, RecipientContext recipient)
		{
			if (IsTemporaryPublicAccessExpired(authority, GetUtcNowSeconds()))
			{
				if (authority.Builder.IsValid)
				{
					return string.Equals(authority.Builder.AccountId, recipient.OwnerId, StringComparison.Ordinal);
				}
				return false;
			}
			if (authority.Owner.IsValid && string.Equals(authority.Owner.Id, recipient.OwnerId, StringComparison.Ordinal))
			{
				return true;
			}
			return authority.AccessMode switch
			{
				PublicPortalAccessMode.Public => true, 
				PublicPortalAccessMode.Invite => true, 
				PublicPortalAccessMode.Tagged => PublicPortalKinds.IsAdminPortalPrefab(authority.PrefabHash) || (!string.IsNullOrWhiteSpace(authority.AuthorizedClanId) && recipient.ClanMembership.ContainsClan(authority.AuthorizedClanId)), 
				PublicPortalAccessMode.Admin => recipient.IsAdmin, 
				PublicPortalAccessMode.Clan => !string.IsNullOrWhiteSpace(authority.AuthorizedClanId) && recipient.ClanMembership.ContainsClan(authority.AuthorizedClanId), 
				_ => false, 
			};
		}

		private static bool TryCheckRecipientRequiredGlobalKey(ServerPortalAuthority authority, RecipientContext recipient, out PortalTravelDenial denial)
		{
			denial = PortalTravelDenial.None;
			if (string.IsNullOrEmpty(authority.RequiredGlobalKey))
			{
				return true;
			}
			if (!authority.RequiredGlobalKeyIsValid)
			{
				denial = new PortalTravelDenial(PortalTravelDenialCode.RequiredGlobalKeyInvalid, "", 0L, 0L);
				return false;
			}
			if (!recipient.RequiredGlobalKeyResults.TryGetValue(authority.RequiredGlobalKey, out var value))
			{
				value = ((recipient.Peer != null) ? RequiredGlobalKeyAccess.QueryPeer(recipient.Peer, authority.RequiredGlobalKey) : RequiredGlobalKeyAccess.QueryLocal(authority.RequiredGlobalKey));
				recipient.RequiredGlobalKeyResults[authority.RequiredGlobalKey] = value;
			}
			if (RequiredGlobalKeyAccess.IsPresent(value))
			{
				return true;
			}
			PortalTravelDenial portalTravelDenial;
			switch (value)
			{
			case RequiredGlobalKeyQueryResult.PersonalMissing:
			case RequiredGlobalKeyQueryResult.SharedMissing:
				portalTravelDenial = new PortalTravelDenial(PortalTravelDenialCode.RequiredGlobalKeyMissing, authority.RequiredGlobalKey, 0L, 0L);
				break;
			case RequiredGlobalKeyQueryResult.Invalid:
				portalTravelDenial = new PortalTravelDenial(PortalTravelDenialCode.RequiredGlobalKeyInvalid, "", 0L, 0L);
				break;
			default:
				portalTravelDenial = new PortalTravelDenial(PortalTravelDenialCode.RequiredGlobalKeyUnavailable, "", 0L, 0L);
				break;
			}
			denial = portalTravelDenial;
			return false;
		}

		private static bool TryResolveActiveBuilder(ZDO zdo, out PortalBuilder builder)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			builder = new PortalBuilder("", "");
			if (_activePortalSync != null)
			{
				if (!_activePortalSync.CreatedIds.Contains(zdo.m_uid))
				{
					return false;
				}
				ZNetPeer val = _activePortalSync?.Peer;
				if (val == null || !val.IsReady() || ((ZDOID)(ref val.m_characterID)).IsNone() || ((ZDOID)(ref zdo.m_uid)).UserID != val.m_uid || zdo.GetOwner() != val.m_uid || ZDOMan.instance == null)
				{
					return false;
				}
				if (!PublicPortalData.TryGetAuthenticatedPeerPlayerId(val, out var playerId) || !PublicPortalData.TryGetPeerSteamId64(val, out string steamId))
				{
					return false;
				}
				long num = zdo.GetLong(ZDOVars.s_creator, 0L);
				if (num == 0L || playerId != num || !PortalAccountStore.TryRememberIdentity(playerId, steamId, out var added))
				{
					return false;
				}
				if (added)
				{
					BackfillBuilderForCreator(playerId, steamId, val.m_playerName);
				}
				builder = SanitizeBuilder(new PortalBuilder(steamId, val.m_playerName, steamId, playerId, 0L));
				return builder.IsValid;
			}
			if (_activeLocalPlacementBuilder.IsValid && (Object)(object)Player.m_localPlayer != (Object)null)
			{
				long playerID = Player.m_localPlayer.GetPlayerID();
				long num2 = zdo.GetLong(ZDOVars.s_creator, 0L);
				if (playerID == 0L || num2 == 0L || num2 != playerID || !PortalAccountStore.TryResolveSteamId(playerID, out string steamId2) || !string.Equals(steamId2, _activeLocalPlacementBuilder.AccountId, StringComparison.Ordinal))
				{
					return false;
				}
				builder = SanitizeBuilder(_activeLocalPlacementBuilder);
				return builder.IsValid;
			}
			return false;
		}

		private static bool IsAuthenticatedRemoteAdminPortalCreation(ZDO zdo, ZNetPeer? peer)
		{
			//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_001c: 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_0091: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = zdo.GetPosition();
			if (_activePortalSync != null && _activePortalSync.CreatedIds.Contains(zdo.m_uid) && peer != null && peer.IsReady() && ((ZDOID)(ref zdo.m_uid)).UserID == peer.m_uid && zdo.GetOwner() == peer.m_uid && (Object)(object)ZNet.instance != (Object)null && PublicPortalData.IsPeerAdmin(ZNet.instance, peer) && PublicPortalData.TryGetPeerOwner(peer, out var _) && PublicPortalData.TryGetAuthenticatedPeerCharacterPosition(peer, out var position2) && IsSafePortalPosition(position) && TryNormalizePortalRotation(zdo.GetRotation(), out var _))
			{
				return Vector3.Distance(position2, position) <= 15f;
			}
			return false;
		}

		private static ServerPortalAuthority SetServerAuthority(ZDOID portalId, ServerPortalAuthority authority)
		{
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: 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_02a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			if (authority.Builder.IsValid)
			{
				PortalBuilder builder = authority.Builder;
				if (builder.BuildSequence <= 0)
				{
					builder = builder.WithBuildSequence(NextBuildSequence());
				}
				else
				{
					_nextBuildSequence = Math.Max(_nextBuildSequence, builder.BuildSequence);
				}
				if (builder.BuildSequence != authority.Builder.BuildSequence)
				{
					authority = new ServerPortalAuthority(authority.AccessMode, authority.Owner, authority.AuthorizedClanId, builder, authority.PrefabHash, authority.FavoriteId, authority.RequiredGlobalKey, authority.PublicExpiresAtUtcSeconds);
				}
			}
			if (authority.Builder.IsValid && !PublicPortalKinds.IsAdminPortalPrefab(authority.PrefabHash) && (!string.Equals(authority.Owner.Id, authority.Builder.AccountId, StringComparison.Ordinal) || !string.Equals(authority.Owner.Name, authority.Builder.Name, StringComparison.Ordinal)))
			{
				authority = new ServerPortalAuthority(authority.AccessMode, new PortalOwner(authority.Builder.AccountId, authority.Builder.Name), authority.AuthorizedClanId, authority.Builder, authority.PrefabHash, authority.FavoriteId, authority.RequiredGlobalKey, authority.PublicExpiresAtUtcSeconds);
			}
			string normalizedFavoriteId;
			bool num = PublicPortalData.TryNormalizeFavoriteId(authority.FavoriteId, out normalizedFavoriteId);
			ZDOID value;
			bool flag = num && ServerPortalsByFavoriteId.TryGetValue(normalizedFavoriteId, out value) && value != portalId;
			if (!num || flag)
			{
				normalizedFavoriteId = CreateServerFavoriteId();
			}
			if (!string.Equals(authority.FavoriteId, normalizedFavoriteId, StringComparison.Ordinal))
			{
				authority = new ServerPortalAuthority(authority.AccessMode, authority.Owner, authority.AuthorizedClanId, authority.Builder, authority.PrefabHash, normalizedFavoriteId, authority.RequiredGlobalKey, authority.PublicExpiresAtUtcSeconds);
			}
			ServerPortalAuthority value2;
			bool num2 = ServerAuthority.TryGetValue(portalId, out value2);
			if (num2 && !string.Equals(value2.FavoriteId, normalizedFavoriteId, StringComparison.Ordinal) && ServerPortalsByFavoriteId.TryGetValue(value2.FavoriteId, out var value3) && value3 == portalId)
			{
				ServerPortalsByFavoriteId.Remove(value2.FavoriteId);
			}
			if (num2 && value2.Builder.IsValid && !string.Equals(value2.Builder.AccountId, authority.Builder.AccountId, StringComparison.Ordinal))
			{
				RemoveBuilderPortal(value2.Builder.AccountId, portalId);
			}
			ServerAuthority[portalId] = authority;
			ServerPortalsByFavoriteId[normalizedFavoriteId] = portalId;
			if (!authority.Builder.IsValid)
			{
				return authority;
			}
			if (!ServerPortalsByBuilder.TryGetValue(authority.Builder.AccountId, out HashSet<ZDOID> value4))
			{
				value4 = new HashSet<ZDOID>();
				ServerPortalsByBuilder.Add(authority.Builder.AccountId, value4);
			}
			value4.Add(portalId);
			return authority;
		}

		private static long NextBuildSequence()
		{
			if (_nextBuildSequence < long.MaxValue)
			{
				_nextBuildSequence++;
				return _nextBuildSequence;
			}
			long num = 1L;
			HashSet<long> hashSet = (from authority in ServerAuthority.Values
				where authority.Builder.BuildSequence > 0
				select authority.Builder.BuildSequence).ToHashSet();
			if (ZDOMan.instance != null)
			{
				foreach (ZDO portal in ZDOMan.instance.GetPortals())
				{
					if (portal != null && portal.GetInt("PortalRules BuilderAuthorityVersion", 0) >= 2)
					{
						long num2 = portal.GetLong("PortalRules BuildSequence", 0L);
						if (num2 > 0)
						{
							hashSet.Add(num2);
						}
					}
				}
			}
			for (; num < long.MaxValue && hashSet.Contains(num); num++)
			{
			}
			return num;
		}

		private static void SeedNextBuildSequence(IEnumerable<ZDO> portals)
		{
			foreach (ServerPortalAuthority value in ServerAuthority.Values)
			{
				_nextBuildSequence = Math.Max(_nextBuildSequence, value.Builder.BuildSequence);
			}
			foreach (ZDO portal in portals)
			{
				if (portal != null && portal.GetInt("PortalRules BuilderAuthorityVersion", 0) >= 2)
				{
					_nextBuildSequence = Math.Max(_nextBuildSequence, portal.GetLong("PortalRules BuildSequence", 0L));
				}
			}
		}

		private static void RemoveServerAuthority(ZDOID portalId)
		{
			//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)
			//IL_002c: 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_0048: 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)
			AdminPortalTags.Remove(portalId);
			if (ServerAuthority.TryGetValue(portalId, out var value))
			{
				InviteTravelCooldownStore.RemovePortal(value.FavoriteId);
				ServerAuthority.Remove(portalId);
				if (ServerPortalsByFavoriteId.TryGetValue(value.FavoriteId, out var value2) && value2 == portalId)
				{
					ServerPortalsByFavoriteId.Remove(value.FavoriteId);
				}
				if (value.Builder.IsValid)
				{
					RemoveBuilderPortal(value.Builder.AccountId, portalId);
				}
			}
		}

		private static void RemoveBuilderPortal(string builderAccountId, ZDOID portalId)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (ServerPortalsByBuilder.TryGetValue(builderAccountId, out HashSet<ZDOID> value))
			{
				value.Remove(portalId);
				if (value.Count == 0)
				{
					ServerPortalsByBuilder.Remove(builderAccountId);
				}
			}
		}

		private static PortalBuilder SanitizeBuilder(PortalBuilder builder)
		{
			string steamId;
			string text = (PublicPortalData.TryNormalizeSteamId64(builder.AccountId, out steamId) ? steamId : "");
			return new PortalBuilder(text, Truncate(builder.Name, 128), string.IsNullOrWhiteSpace(builder.PlatformId) ? text : Truncate(builder.PlatformId, 128), builder.CharacterPlayerId, builder.BuildSequence);
		}

		private static PortalOwner SanitizeOwner(PortalOwner owner)
		{
			string text = owner.Id ?? "";
			if (text.Length > 128)
			{
				text = "";
			}
			return new PortalOwner(text, Truncate(owner.Name, 128));
		}

		private static string SanitizeClanId(string clanId)
		{
			clanId = (clanId ?? "").Trim();
			if (clanId.Length > 128)
			{
				return "";
			}
			return clanId;
		}

		private static string Truncate(string value, int maximumLength)
		{
			if (value == null)
			{
				value = "";
			}
			if (value.Length > maximumLength)
			{
				return value.Substring(0, maximumLength);
			}
			return value;
		}

		private static bool IsFinite(Vector3 value)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (IsFinite(value.x) && IsFinite(value.y))
			{
				return IsFinite(value.z);
			}
			return false;
		}

		private static bool IsSafePortalPosition(Vector3 value)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if (IsFinite(value) && Math.Abs(value.x) <= 1000000f && Math.Abs(value.y) <= 1000000f)
			{
				return Math.Abs(value.z) <= 1000000f;
			}
			return false;
		}

		private static bool IsFinite(Quaternion value)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if (IsFinite(value.x) && IsFinite(value.y) && IsFinite(value.z))
			{
				return IsFinite(value.w);
			}
			return false;
		}

		private static bool TryNormalizePortalRotation(Quaternion value, out Quaternion normalized)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0024: 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_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: 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_0082: 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_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			normalized = Quaternion.identity;
			if (!IsFinite(value))
			{
				return false;
			}
			double num = (double)value.x * (double)value.x + (double)value.y * (double)value.y + (double)value.z * (double)value.z + (double)value.w * (double)value.w;
			if (num < 0.25 || num > 4.0)
			{
				return false;
			}
			float num2 = (float)(1.0 / Math.Sqrt(num));
			normalized = new Quaternion(value.x * num2, value.y * num2, value.z * num2, value.w * num2);
			return IsFinite(normalized);
		}

		private static bool IsFinite(float value)
		{
			if (!float.IsNaN(value))
			{
				return !float.IsInfinity(value);
			}
			return false;
		}

		private static bool SnapshotsMatch(IReadOnlyList<PublicPortalCatalogEntry> left, IReadOnlyList<PublicPortalCatalogEntry> right)
		{
			if (left.Count != right.Count)
			{
				return false;
			}
			for (int i = 0; i < left.Count; i++)
			{
				if (!left[i].HasSameContent(right[i]))
				{
					return false;
				}
			}
			return true;
		}
	}
	internal static class PublicPortalServerPolicy
	{
		private sealed class PendingRemoval
		{
			public readonly ZDOID PortalId;

			public int Attempts;

			public float NextAttemptAt;

			public PendingRemoval(ZDOID portalId)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				PortalId = portalId;
			}
		}

		private readonly struct QuotaState
		{
			public readonly int EffectiveLimit;

			public readonly int CurrentCount;

			public readonly int EffectiveInviteLimit;

			public readonly int CurrentInviteCount;

			public QuotaState(int effectiveLimit, int currentCount, int effectiveInviteLimit, int currentInviteCount)
			{
				EffectiveLimit = effectiveLimit;
				CurrentCount = currentCount;
				EffectiveInviteLimit = effectiveInviteLimit;
				CurrentInviteCount = currentInviteCount;
			}

			public bool Matches(QuotaState other)
			{
				if (EffectiveLimit == other.EffectiveLimit && CurrentCount == other.CurrentCount && EffectiveInviteLimit == other.EffectiveInviteLimit)
				{
					return CurrentInviteCount == other.CurrentInviteCount;
				}
				return false;
			}
		}

		private const string PolicyMessageRpc = "sighsorry.PortalRules.PolicyMessage.v2";

		private const string QuotaStateRpc = "sighsorry.PortalRules.QuotaState.v2";

		private const string InfinityHammerPluginGuid = "infinity_hammer";

		private const byte QuotaStateFormatVersion = 2;

		private const int MaximumPortalLimit = 10000;

		private const int MaximumPortalCount = 100000;

		private const int MaximumRemovalAttemptsBeforeWarning = 5;

		private const int MaximumQueuedRemovalsPerFrame = 10;

		private static readonly Queue<PendingRemoval> PendingRemovals = new Queue<PendingRemoval>();

		private static readonly Dictionary<ZDOID, PendingRemoval> DeferredRemovals = new Dictionary<ZDOID, PendingRemoval>();

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

		private static readonly Dictionary<ZRpc, QuotaState> LastSentQuotaStates = new Dictionary<ZRpc, QuotaState>();

		private static Game? _registeredGame;

		private static ZNet? _sessionZNet;

		private static string _cachedCountedPrefabSetting = "";

		private static long _sessionGeneration;

		private static bool _hasClientQuotaState;

		private static int _clientEffectiveLimit = -1;

		private static int _clientCurrentCount;

		private static int _clientEffectiveInviteLimit = -1;

		private static int _clientCurrentInviteCount;

		private static MethodInfo? _infinityHammerNoCreatorGetter;

		private static MethodInfo? _infinityHammerSelectionGetter;

		private static Type? _infinityHammerObjectSelectionType;

		internal static void BeginNetworkSession(ZNet? znet)
		{
			if (!((Object)(object)znet == (Object)null) && _sessionZNet != znet)
			{
				ResetSessionState();
				_sessionZNet = znet;
			}
		}

		internal static void Register(Game game)
		{
			if (!((Object)(object)game == (Object)null) && !((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer() && _registeredGame != game)
			{
				_registeredGame = game;
				_sessionZNet = ZNet.instance;
				long sessionGeneration = _sessionGeneration;
				((MonoBehaviour)game).StartCoroutine(ServerRemovalLoop(game, _sessionZNet, sessionGeneration));
			}
		}

		internal static void Shutdown()
		{
			ResetSessionState();
			_sessionZNet = null;
		}

		internal static void RegisterPeer(ZNet znet, ZNetPeer peer)
		{
			if (!((Object)(object)znet == (Object)null) && peer?.m_rpc != null && !znet.IsServer())
			{
				ResetClientQuotaState();
				peer.m_rpc.Register<ZPackage>("sighsorry.PortalRules.PolicyMessage.v2", (Action<ZRpc, ZPackage>)OnPolicyMessage);
				peer.m_rpc.Register<ZPackage>("sighsorry.PortalRules.QuotaState.v2", (Action<ZRpc, ZPackage>)OnQuotaState);
			}
		}

		internal static void ForgetPeer(ZRpc? rpc)
		{
			if (rpc != null)
			{
				LastSentQuotaStates.Remove(rpc);
				if ((Object)(object)ZNet.instance != (Object)null && !ZNet.instance.IsServer() && rpc == ZNet.instance.GetServerRPC())
				{
					ResetClientQuotaState();
				}
			}
		}

		internal static void SendQuotaState(ZNetPeer? peer, bool force = false)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer() && PublicPortalCatalog.IsServerReady && peer?.m_rpc != null && peer.IsReady() && peer.m_rpc.IsConnected() && PublicPortalCatalog.TryEnsurePeerIdentity(peer, out string steamId))
			{
				QuotaState quotaState = BuildQuotaState(steamId);
				if (force || !LastSentQuotaStates.TryGetValue(peer.m_rpc, out var value) || !value.Matches(quotaState))
				{
					ZPackage val = new ZPackage();
					val.Write((byte)2);
					val.Write(quotaState.EffectiveLimit);
					val.Write(quotaState.CurrentCount);
					val.Write(quotaState.EffectiveInviteLimit);
					val.Write(quotaState.CurrentInviteCount);
					peer.m_rpc.Invoke("sighsorry.PortalRules.QuotaState.v2", new object[1] { val });
					LastSentQuotaStates[peer.m_rpc] = quotaState;
				}
			}
		}

		internal static void BroadcastQuotaStates()
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			foreach (ZNetPeer peer in ZNet.instance.GetPeers())
			{
				SendQuotaState(peer);
			}
			RefreshLocalServerQuotaState();
		}

		internal static void NotifyQuotaConfigurationChanged()
		{
			RefreshCountedPortalHashes();
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
			{
				PublicPortalCatalog.RefreshCountedPortalConfiguration();
			}
			else
			{
				BroadcastQuotaStates();
			}
		}

		private static QuotaState BuildQuotaState(string steamId)
		{
			int effectiveLimit = (PublicPortalConfig.EnableAccountPortalLimit.Value.IsOff() ? (-1) : PortalAccountStore.GetEffectivePortalLimit(steamId, PublicPortalConfig.MaxPortalsPerAccount.Value));
			int currentCount = Math.Min(100000, PublicPortalCatalog.GetBuilderPortalCount(steamId));
			int effectiveInvitePortalLimit = PortalAccountStore.GetEffectiveInvitePortalLimit(steamId, PublicPortalConfig.MaxInvitePortalsPerAccount.Value);
			int currentInviteCount = Math.Min(100000, PublicPortalCatalog.GetBuilderInvitePortalCount(steamId));
			return new QuotaState(effectiveLimit, currentCount, effectiveInvitePortalLimit, currentInviteCount);
		}

		private static void RefreshLocalServerQuotaState()
		{
			if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer() && PublicPortalCatalog.IsServerReady && PublicPortalCatalog.TryEnsureLocalIdentity(out string steamId))
			{
				QuotaState quotaState = BuildQuotaState(steamId);
				_clientEffectiveLimit = quotaState.EffectiveLimit;
				_clientCurrentCount = quotaState.CurrentCount;
				_clientEffectiveInviteLimit = quotaState.EffectiveInviteLimit;
				_clientCurrentInviteCount = quotaState.CurrentInviteCount;
				_hasClientQuotaState = true;
			}
		}

		internal static bool TryGetInviteQuotaState(string steamId, out int currentCount, out int effectiveLimit)
		{
			currentCount = 0;
			effectiveLimit = 0;
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || !PublicPortalCatalog.IsServerReady || !PublicPortalData.TryNormalizeSteamId64(steamId, out string steamId2))
			{
				return false;
			}
			QuotaState quotaState = BuildQuotaState(steamId2);
			currentCount = quotaState.CurrentInviteCount;
			effectiveLimit = quotaState.EffectiveInviteLimit;
			return true;
		}

		internal static bool TryGetClanQuotaState(string clanId, out int currentCount, out int effectiveLimit)
		{
			currentCount = 0;
			effectiveLimit = Math.Max(-1, Math.Min(10000, PublicPortalConfig.MaxClanPortalsPerClan.Value));
			string text = (clanId ?? "").Trim();
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || !PublicPortalCatalog.IsServerReady || text.Length == 0)
			{
				return false;
			}
			currentCount = Math.Min(100000, PublicPortalCatalog.GetClanPortalCount(text));
			return true;
		}

		internal static bool IsCountedPortalPrefab(int prefabHash)
		{
			RefreshCountedPortalHashes();
			if (prefabHash != 0 && !PublicPortalKinds.IsAdminPortalPrefab(prefabHash))
			{
				return CountedPortalHashes.Contains(prefabHash);
			}
			return false;
		}

		internal static bool TryAcceptNewPortal(ZDO zdo, PortalBuilder builder, ZNetPeer? sourcePeer)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			if (zdo == null || !IsCountedPortalPrefab(zdo.GetPrefab()) || PublicPortalConfig.EnableAccountPortalLimit.Value.IsOff())
			{
				return true;
			}
			if (!PublicPortalData.TryNormalizeSteamId64(builder.AccountId, out string steamId))
			{
				RejectUnverifiedPortal(zdo, sourcePeer);
				return false;
			}
			int effectivePortalLimit = PortalAccountStore.GetEffectivePortalLimit(steamId, PublicPortalConfig.MaxPortalsPerAccount.Value);
			if (effectivePortalLimit < 0)
			{
				return true;
			}
			int builderPortalCount = PublicPortalCatalog.GetBuilderPortalCount(steamId);
			if (builderPortalCount < effectivePortalLimit)
			{
				return true;
			}
			if (PublicPortalCatalog.MarkPendingRemoval(zdo.m_uid))
			{
				QueueRemoval(zdo.m_uid);
			}
			SendPolicyMessage(sourcePeer, new PortalRulesMessage("$sighsorry_portalrules_portal_limit_reached", builderPortalCount.ToString(CultureInfo.InvariantCulture), effectivePortalLimit.ToString(CultureInfo.InvariantCulture)));
			SendQuotaState(sourcePeer, force: true);
			PortalRulesPlugin.PortalRulesLogger.LogWarning((object)($"Rejected portal {zdo.m_uid} from {steamId}: " + $"account already has {builderPortalCount}/{effectivePortalLimit} counted portals."));
			return false;
		}

		internal static void RejectUnverifiedPortal(ZDO zdo, ZNetPeer? sourcePeer)
		{
			//IL_0005: 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_0012: Unknown result type (might be due to invalid IL or missing references)
			if (zdo != null)
			{
				if (PublicPortalCatalog.MarkPendingRemoval(zdo.m_uid))
				{
					QueueRemoval(zdo.m_uid);
				}
				SendPolicyMessage(sourcePeer, new PortalRulesMessage("$sighsorry_portalrules_portal_placement_account_unverified"));
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)$"Rejected unverified portal creation {zdo.m_uid}.");
			}
		}

		internal static bool QueueAdminPortalRemoval(ZDO zdo)
		{
			//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)
			if (zdo == null || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || !zdo.IsValid() || !PublicPortalInteraction.IsAdminPortal(zdo) || !PublicPortalCatalog.MarkPendingRemoval(zdo.m_uid))
			{
				return false;
			}
			QueueRemoval(zdo.m_uid);
			PublicPortalCatalog.RefreshAndBroadcast();
			PublicPortalTaggedConnections.RefreshConnections();
			return true;
		}

		internal static bool ShouldBlockLocalPlacement(Piece piece, out string message)
		{
			message = "";
			if ((Object)(object)piece == (Object)null || PublicPortalConfig.EnableAccountPortalLimit.Value.IsOff() || !IsCountedPortalPrefab(StringExtensionMethods.GetStableHashCode(Utils.GetPrefabName(((Component)piece).gameObject))))
			{
				return false;
			}
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer() && IsInfinityHammerNoCreatorActive())
			{
				return false;
			}
			string text = PortalRulesLocalization.Translate("$sighsorry_portalrules_portal_limit_syncing");
			int num;
			int num2;
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
			{
				if (!PublicPortalCatalog.IsServerReady || !PublicPortalCatalog.TryEnsureLocalIdentity(out string steamId))
				{
					message = text;
					return true;
				}
				num = PortalAccountStore.GetEffectivePortalLimit(steamId, PublicPortalConfig.MaxPortalsPerAccount.Value);
				num2 = PublicPortalCatalog.GetBuilderPortalCount(steamId);
			}
			else
			{
				if (!_hasClientQuotaState)
				{
					message = text;
					return true;
				}
				num = _clientEffectiveLimit;
				num2 = _clientCurrentCount;
			}
			if (num < 0)
			{
				return false;
			}
			if (num2 < num)
			{
				return false;
			}
			message = PortalRulesLocalization.Translate("$sighsorry_portalrules_portal_limit_placement_blocked", num.ToString(CultureInfo.InvariantCulture));
			return true;
		}

		private static bool IsInfinityHammerNoCreatorActive()
		{
			try
			{
				if (!TryBindInfinityHammerCompat())
				{
					return false;
				}
				object obj = _infinityHammerNoCreatorGetter?.Invoke(null, null);
				if (!(obj is bool) || !(bool)obj)
				{
					return false;
				}
				object obj2 = _infinityHammerSelectionGetter?.Invoke(null, null);
				return obj2 != null && _infinityHammerObjectSelectionType.IsInstanceOfType(obj2);
			}
			catch (Exception)
			{
				return false;
			}
		}

		private static bool TryBindInfinityHammerCompat()
		{
			if (_infinityHammerNoCreatorGetter != null && _infinityHammerSelectionGetter != null && _infinityHammerObjectSelectionType != null)
			{
				return true;
			}
			if (!Chainloader.PluginInfos.TryGetValue("infinity_hammer", out var value))
			{
				return false;
			}
			Assembly obj = ((object)value.Instance)?.GetType().Assembly;
			Type type = obj?.GetType("InfinityHammer.Configuration", throwOnError: false, ignoreCase: false);
			Type type2 = obj?.GetType("InfinityHammer.Selection", throwOnError: false, ignoreCase: false);
			Type type3 = obj?.GetType("InfinityHammer.ObjectSelection", throwOnError: false, ignoreCase: false);
			MethodInfo methodInfo = type?.GetProperty("NoCreator", BindingFlags.Static | BindingFlags.Public)?.GetGetMethod(nonPublic: false);
			MethodInfo methodInfo2 = type2?.GetMethod("Get", BindingFlags.Static | BindingFlags.Public, null, Type.EmptyTypes, null);
			if (methodInfo?.ReturnType != typeof(bool) || methodInfo2 == null || type3 == null)
			{
				return false;
			}
			_infinityHammerNoCreatorGetter = methodInfo;
			_infinityHammerSelectionGetter = methodInfo2;
			_infinityHammerObjectSelectionType = type3;
			return true;
		}

		private static IEnumerator ServerRemovalLoop(Game game, ZNet sessionZNet, long generation)
		{
			while (IsActiveSession(game, sessionZNet, generation))
			{
				PromoteDeferredRemovals();
				if (PendingRemovals.Count > 0)
				{
					ProcessPendingRemovals(10);
					yield return null;
				}
				else
				{
					yield return (object)new WaitForSeconds(1f);
				}
			}
		}

		private static void QueueRemoval(ZDOID portalId)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!((ZDOID)(ref portalId)).IsNone())
			{
				PendingRemovals.Enqueue(new PendingRemoval(portalId));
			}
		}

		private static void ProcessPendingRemovals(int maximumCount)
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			int num = Math.Min(Math.Max(0, maximumCount), PendingRemovals.Count);
			for (int i = 0; i < num; i++)
			{
				PendingRemoval pendingRemoval = PendingRemovals.Dequeue();
				try
				{
					DestroyPortal(pendingRemoval);
				}
				catch (Exception ex)
				{
					pendingRemoval.Attempts++;
					pendingRemoval.NextAttemptAt = Time.realtimeSinceStartup + Math.Min(60f, (float)Math.Pow(2.0, Math.Min(pendingRemoval.Attempts, 6)));
					DeferredRemovals[pendingRemoval.PortalId] = pendingRemoval;
					if (pendingRemoval.Attempts == 1)
					{
						PortalRulesPlugin.PortalRulesLogger.LogError((object)$"Failed to remove portal {pendingRemoval.PortalId}: {ex.Message}");
					}
					else if (pendingRemoval.Attempts == 5)
					{
						PortalRulesPlugin.PortalRulesLogger.LogWarning((object)($"Portal {pendingRemoval.PortalId} removal has failed repeatedly; " + "the server will retry with backoff. Last error: " + ex.Message));
					}
				}
			}
		}

		private static void PromoteDeferredRemovals()
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			if (DeferredRemovals.Count == 0)
			{
				return;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			List<PendingRemoval> list = new List<PendingRemoval>();
			foreach (PendingRemoval value in DeferredRemovals.Values)
			{
				if (value.NextAttemptAt <= realtimeSinceStartup)
				{
					list.Add(value);
				}
			}
			foreach (PendingRemoval item in list)
			{
				DeferredRemovals.Remove(item.PortalId);
				PendingRemovals.Enqueue(item);
			}
		}

		private static void DestroyPortal(PendingRemoval removal)
		{
			//IL_00c6: 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_002d: 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)
			ZDOMan instance = ZDOMan.instance;
			if (instance == null)
			{
				throw new InvalidOperationException("ZDO manager is unavailable.");
			}
			ZDO zDO = instance.GetZDO(removal.PortalId);
			if (zDO == null || !zDO.IsValid())
			{
				PublicPortalCatalog.NotifyPortalDestroyed(removal.PortalId);
				return;
			}
			zDO.SetOwner(ZDOMan.GetSessionID());
			ZNetScene instance2 = ZNetScene.instance;
			GameObject val = ((instance2 != null) ? instance2.FindInstance(removal.PortalId) : null);
			if ((Object)(object)val != (Object)null)
			{
				try
				{
					WearNTear component = val.GetComponent<WearNTear>();
					ZNetView component2 = val.GetComponent<ZNetView>();
					bool flag = (Object)(object)component2 != (Object)null && component2.IsValid();
					if ((Object)(object)component != (Object)null && flag)
					{
						component.Remove(true);
					}
					else
					{
						instance2.Destroy(val);
						if (!flag)
						{
							instance.DestroyZDO(zDO);
						}
					}
					return;
				}
				catch (Exception ex)
				{
					PortalRulesPlugin.PortalRulesLogger.LogError((object)($"Portal instance removal failed for {removal.PortalId}; " + "falling back to ZDO removal: " + ex.Message));
					instance.DestroyZDO(zDO);
					return;
				}
			}
			instance.DestroyZDO(zDO);
		}

		internal static void SendPolicyMessage(ZNetPeer? peer, PortalRulesMessage message)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			if (message.IsEmpty)
			{
				return;
			}
			if (peer != null)
			{
				if (peer.m_rpc != null && peer.m_rpc.IsConnected())
				{
					ZPackage val = new ZPackage();
					message.Write(val);
					peer.m_rpc.Invoke("sighsorry.PortalRules.PolicyMessage.v2", new object[1] { val });
				}
			}
			else
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)2, message.Localize(), 0, (Sprite)null);
				}
			}
		}

		private static void OnPolicyMessage(ZRpc rpc, ZPackage package)
		{
			if ((Object)(object)ZNet.instance == (Object)null || ZNet.instance.IsServer() || rpc != ZNet.instance.GetServerRPC())
			{
				return;
			}
			try
			{
				if (!PortalRulesMessage.TryRead(package, out var message))
				{
					PortalRulesPlugin.PortalRulesLogger.LogWarning((object)"Ignored a malformed PortalRules policy message from the server.");
					return;
				}
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)2, message.Localize(), 0, (Sprite)null);
				}
			}
			catch (Exception ex)
			{
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("Failed to read a PortalRules policy message: " + ex.Message));
			}
		}

		private static void OnQuotaState(ZRpc rpc, ZPackage package)
		{
			if ((Object)(object)ZNet.instance == (Object)null || ZNet.instance.IsServer() || rpc != ZNet.instance.GetServerRPC())
			{
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)"Ignored portal quota state from a non-server connection.");
				return;
			}
			try
			{
				byte num = package.ReadByte();
				int num2 = package.ReadInt();
				int num3 = package.ReadInt();
				int num4 = package.ReadInt();
				int num5 = package.ReadInt();
				if (num != 2 || num2 < -1 || num2 > 10000 || num3 < 0 || num3 > 100000 || num4 < -1 || num4 > 10000 || num5 < 0 || num5 > 100000)
				{
					PortalRulesPlugin.PortalRulesLogger.LogWarning((object)"Ignored malformed portal quota state from the server.");
					return;
				}
				_clientEffectiveLimit = num2;
				_clientCurrentCount = num3;
				_clientEffectiveInviteLimit = num4;
				_clientCurrentInviteCount = num5;
				_hasClientQuotaState = true;
			}
			catch (Exception ex)
			{
				PortalRulesPlugin.PortalRulesLogger.LogError((object)("Failed to read portal quota state: " + ex.Message));
			}
		}

		private static void RefreshCountedPortalHashes()
		{
			string text = PublicPortalConfig.CountedPortalPrefabs.Value ?? "";
			if (string.Equals(text, _cachedCountedPrefabSetting, StringComparison.Ordinal))
			{
				return;
			}
			_cachedCountedPrefabSetting = text;
			CountedPortalHashes.Clear();
			string[] array = text.Split(new char[1] { ',' });
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (!string.IsNullOrWhiteSpace(text2))
				{
					CountedPortalHashes.Add(StringExtensionMethods.GetStableHashCode(text2));
				}
			}
		}

		private static bool IsActiveSession(Game game, ZNet sessionZNet, long generation)
		{
			if (generation == _sessionGeneration && _registeredGame == game && _sessionZNet == sessionZNet && ZNet.instance == sessionZNet)
			{
				return sessionZNet.IsServer();
			}
			return false;
		}

		private static void ResetSessionState()
		{
			_sessionGeneration++;
			_registeredGame = null;
			PendingRemovals.Clear();
			DeferredRemovals.Clear();
			LastSentQuotaStates.Clear();
			ResetClientQuotaState();
		}

		private static void ResetClientQuotaState()
		{
			_hasClientQuotaState = false;
			_clientEffectiveLimit = -1;
			_clientCurrentCount = 0;
			_clientEffectiveInviteLimit = -1;
			_clientCurrentInviteCount = 0;
		}
	}
	internal static class PublicPortalAccess
	{
		public static bool CanUsePortal(ZDO zdo)
		{
			//IL_0006: 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 (zdo == null)
			{
				return false;
			}
			if (PublicPortalCatalog.TryCanLocalServerUserUsePortal(zdo.m_uid, out var canUse))
			{
				return canUse;
			}
			if ((Object)(object)ZNet.instance != (Object)null && !ZNet.instance.IsServer())
			{
				if (PublicPortalCatalog.HasSnapshot && PublicPortalCatalog.TryGetClientEntry(zdo.m_uid, out var entry))
				{
					return CanUsePortal(entry);
				}
				return false;
			}
			if (!CanUsePortal(PublicPortalCatalog.GetEffectiveAccessMode(zdo), PublicPortalCatalog.GetEffectiveOwner(zdo)))
			{
				return false;
			}
			return RequiredGlobalKeyAccess.IsPresent(RequiredGlobalKeyAccess.QueryLocal(PublicPortalCatalog.GetEffectiveRequiredGlobalKey(zdo)));
		}

		public static bool CanUsePortal(PublicPortalCatalogEntry portal)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if (PublicPortalCatalog.TryCanLocalServerUserUsePortal(portal.Id, out var canUse))
			{
				return canUse;
			}
			if (portal.AccessMode == PublicPortalAccessMode.Clan && (Object)(object)ZNet.instance != (Object)null && !ZNet.instance.IsServer())
			{
				return true;
			}
			return CanUsePortal(portal.AccessMode, portal.Owner);
		}

		private static bool CanUsePortal(PublicPortalAccessMode mode, PortalOwner owner)
		{
			if ((mode == PublicPortalAccessMode.Public || (uint)(mode - 4) <= 1u) ? true : false)
			{
				return true;
			}
			if (PublicPortalData.IsLocalOwner(owner))
			{
				return true;
			}
			return mode switch
			{
				PublicPortalAccessMode.Admin => PortalRulesPlugin.IsAdmin, 
				PublicPortalAccessMode.Clan => false, 
				_ => false, 
			};
		}

		public static bool CanEditPortal(ZDO zdo)
		{
			if (zdo == null)
			{
				return false;
			}
			if (PublicPortalInteraction.IsAdminPortal(zdo))
			{
				return PortalRulesPlugin.HasAdminDebugAccess;
			}
			PortalBuilder builder = PublicPortalData.GetBuilder(zdo);
			if (!builder.IsValid)
			{
				return false;
			}
			if (PublicPortalData.TryGetLocalSteamId64(out string steamId) && string.Equals(steamId, builder.AccountId, StringComparison.Ordinal))
			{
				return true;
			}
			if (PublicPortalCatalog.GetEffectiveAccessMode(zdo) == PublicPortalAccessMode.Invite)
			{
				return false;
			}
			if (!PortalRulesPlugin.HasAdminDebugAccess)
			{
				return ClanPortalAccess.IsRequesterInBuilderPrimaryClan(builder, null);
			}
			return true;
		}
	}
	[HarmonyPatch]
	internal static class PublicPortalInteraction
	{
		[HarmonyPatch(typeof(Game), "Start")]
		private static class RegisterRpcPatch
		{
			private static void Postfix(Game __instance)
			{
				LastAccessModeRequestAt.Clear();
				PublicPortalMapController.Instance.End();
				PublicPortalCatalog.Register(__instance);
				PublicPortalServerPolicy.Register(__instance);
			}
		}

		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		private static class RegisterPeerRpcPatch
		{
			private static void Postfix(ZNet __instance, ZNetPeer peer)
			{
				PublicPortalCatalog.RegisterPeer(__instance, peer);
				PublicPortalServerPolicy.RegisterPeer(__instance, peer);
				PublicPortalTeleportService.RegisterPeer(__instance, peer);
				PublicPortalModeChangeEffects.RegisterPeer(__instance, peer);
				AdminPortalOperations.RegisterPeer(__instance, peer);
				if (__instance.IsServer())
				{
					peer.m_rpc.Register<ZDOID, int, bool>("sighsorry.PortalRules.ChangeAccessMode.v4", (Action<ZRpc, ZDOID, int, bool>)OnRemoteAccessModeChange);
				}
				else
				{
					peer.m_rpc.Register<ZPackage>("sighsorry.PortalRules.ChangeAccessModeResult.v5", (Action<ZRpc, ZPackage>)OnAccessModeChangeResult);
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "Awake")]
		private static class BeginNetworkSessionPatch
		{
			private static void Postfix(ZNet __instance)
			{
				PublicPortalCatalog.BeginNetworkSession(__instance);
				PublicPortalServerPolicy.BeginNetworkSession(__instance);
				PublicPortalTeleportService.BeginNetworkSession(__instance);
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		private static class RegisterPeerIdentityPatch
		{
			private static void Postfix(ZNet __instance, ZRpc rpc)
			{
				RefreshPeerIdentity(__instance, rpc);
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_CharacterID")]
		private static class RegisterPeerCharacterIdentityPatch
		{
			private static void Postfix(ZNet __instance, ZRpc rpc)
			{
				RefreshPeerIdentity(__instance, rpc);
			}
		}

		[HarmonyPatch(typeof(ZNet), "Disconnect")]
		private static class CleanupPeerStatePatch
		{
			private static void Prefix(ZNetPeer peer)
			{
				if (peer?.m_rpc != null)
				{
					LastAccessModeRequestAt.Remove(peer.m_rpc);
					PublicPortalCatalog.ForgetPeer(peer.m_rpc);
					PublicPortalServerPolicy.ForgetPeer(peer.m_rpc);
					PublicPortalTeleportService.ForgetPeer(peer.m_rpc);
					AdminPortalOperations.ForgetPeer(peer.m_rpc);
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "LoadWorld")]
		private static class ServerWorldLoadedPatch
		{
			private static void Postfix(ZNet __instance)
			{
				PublicPortalCatalog.NotifyServerWorldLoaded(__instance);
			}
		}

		[HarmonyPatch(typeof(TeleportWorld), "Awake")]
		private static class ObservePortalPatch
		{
			private static void Postfix(TeleportWorld __instance)
			{
				if (PublicPortalKinds.IsHandledPortal(__instance) && !((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer())
				{
					ZDO portalZdo = PublicPortalKinds.GetPortalZdo(__instance);
					if (portalZdo != null)
					{
						PublicPortalCatalog.ObservePortal(portalZdo);
					}
				}
			}
		}

		[HarmonyPatch(typeof(ZDOMan), "AddPortal")]
		private static class ObserveAddedPortalPatch
		{
			private static void Postfix(ZDO zdo)
			{
				if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
				{
					PublicPortalCatalog.ObservePortal(zdo);
				}
			}
		}

		[HarmonyPatch(typeof(ZDOMan), "RPC_ZDOData")]
		private static class BindPortalCreationToTransportPatch
		{
			private static void Prefix(ZRpc rpc, out PublicPortalCatalog.PortalSyncContext? __state)
			{
				__state = PublicPortalCatalog.BeginPortalSync(rpc);
			}

			private static Exception? Finalizer(Exception? __exception, PublicPortalCatalog.PortalSyncContext? __state)
			{
				PublicPortalCatalog.RestorePortalSync(__state);
				return __exception;
			}
		}

		[HarmonyPatch(typeof(ZDOMan), "CreateNewZDO", new Type[]
		{
			typeof(ZDOID),
			typeof(Vector3),
			typeof(int)
		})]
		private static class ObserveRemoteCreatedZdoPatch
		{
			private static void Postfix(ZDO __result)
			{
				PublicPortalCatalog.ObserveRemoteZdoCreated(__result);
			}
		}

		[HarmonyPatch(typeof(Player), "TryPlacePiece")]
		private static class PreviewPortalLimitPatch
		{
			private static bool Prefix(Player __instance, Piece piece, ref bool __result)
			{
				if ((Object)(object)__instance == (Object)null || (Object)(object)__instance != (Object)(object)Player.m_localPlayer || !PublicPortalServerPolicy.ShouldBlockLocalPlacement(piece, out string message))
				{
					return true;
				}
				((Character)__instance).Message((MessageType)2, message, 0, (Sprite)null);
				__result = false;
				return false;
			}
		}

		[HarmonyPatch(typeof(Player), "PlacePiece")]
		private static class BindLocalPortalPlacementPatch
		{
			private static void Prefix(Player __instance, out LocalPortalPlacementState __state)
			{
				__state = PublicPortalCatalog.BeginLocalPlacement(__instance);
			}

			private static Exception? Finalizer(Exception? __exception, LocalPortalPlacementState __state)
			{
				try
				{
					PublicPortalCatalog.CompleteLocalPlacement(__state);
				}
				catch (Exception ex)
				{
					PortalRulesPlugin.PortalRulesLogger.LogError((object)("Failed to finalize local portal placement authority: " + ex.Message));
				}
				return __exception;
			}
		}

		[HarmonyPatch(typeof(ZDOMan), "HandleDestroyedZDO")]
		private static class ObserveDestroyedPortalPatch
		{
			private static void Prefix(ZDOID uid)
			{
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
				{
					PublicPortalCatalog.NotifyPortalDestroyed(uid);
				}
			}
		}

		[HarmonyPatch(typeof(ZDOMan), "PrepareSave")]
		private static class ReconcileBeforeWorldSavePatch
		{
			private static void Prefix()
			{
				PublicPortalCatalog.ReconcileAuthorityToZdos();
				PortalAccountStore.FlushPlayerIdentities();
				InviteTravelCooldownStore.Flush();
			}
		}

		[HarmonyPatch(typeof(TeleportWorld), "GetHoverText")]
		private static class HoverTextPatch
		{
			private static void Postfix(TeleportWorld __instance, ref string __result)
			{
				//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_0188: Unknown result type (might be due to invalid IL or missing references)
				if (!PublicPortalKinds.IsHandledPortal(__instance))
				{
					return;
				}
				ZDO portalZdo = PublicPortalKinds.GetPortalZdo(__instance);
				if (portalZdo == null)
				{
					return;
				}
				PublicPortalAccessMode effectiveAccessMode = PublicPortalCatalog.GetEffectiveAccessMode(portalZdo);
				if (PublicPortalAccess.CanEditPortal(portalZdo))
				{
					string text = ((Localization.instance != null) ? Localization.instance.Localize("$KEY_Use") : "$KEY_Use");
					__result = __result + "\n" + PortalRulesLocalization.Translate("$sighsorry_portalrules_hover_change_access_mode", ((object)PublicPortalConfig.ToggleAccessKey.Value/*cast due to .constrained prefix*/).ToString(), text, AccessModeLabel(effectiveAccessMode));
				}
				if (!IsAdminPortal(portalZdo) && effectiveAccessMode == PublicPortalAccessMode.Public && TryGetTemporaryPublicRemainingSeconds(portalZdo, out var remainingSeconds))
				{
					__result = __result + "\n" + PortalRulesLocalization.Translate("$sighsorry_portalrules_hover_temporary_public_remaining", remainingSeconds.ToString());
				}
				switch (effectiveAccessMode)
				{
				case PublicPortalAccessMode.Invite:
				{
					string text2 = PortalRulesLocalization.Translate("$sighsorry_portalrules_hover_invite_description");
					string text3 = "";
					if (PublicPortalCatalog.TryGetClientEntry(portalZdo.m_uid, out var entry2))
					{
						string[] array2 = new string[2];
						int modeCurrent = entry2.ModeCurrent;
						array2[0] = modeCurrent.ToString();
						array2[1] = FormatPortalLimit(entry2.ModeLimit);
						text2 = PortalRulesLocalization.Translate("$sighsorry_portalrules_hover_invite_description_with_quota", array2);
						long remainingSeconds2 = InviteTravelCooldownStore.GetRemainingSeconds(entry2.InviteDepartureCooldownUntilUtc);
						if (remainingSeconds2 > 0)
						{
							text3 = PortalRulesLocalization.Translate("$sighsorry_portalrules_invite_departure_cooldown", InviteTravelCooldownStore.FormatRemaining(remainingSeconds2));
						}
					}
					if (!string.IsNullOrEmpty(text3))
					{
						__result = __result + "\n" + text3;
					}
					__result = __result + "\n" + text2;
					break;
				}
				case PublicPortalAccessMode.Clan:
				{
					if (PublicPortalCatalog.TryGetClientEntry(portalZdo.m_uid, out var entry))
					{
						string obj = __result;
						string[] array = new string[2];
						int modeCurrent = entry.ModeCurrent;
						array[0] = modeCurrent.ToString();
						array[1] = FormatPortalLimit(entry.ModeLimit);
						__result = obj + "\n" + PortalRulesLocalization.Translate("$sighsorry_portalrules_hover_clan_quota", array);
					}
					break;
				}
				}
				if (IsAdminPortal(portalZdo) && PortalRulesPlugin.HasAdminDebugAccess)
				{
					string text4 = ((Localization.instance != null) ? Localization.instance.Localize("$KEY_Use") : "$KEY_Use");
					string effectiveRequiredGlobalKey = PublicPortalCatalog.GetEffectiveRequiredGlobalKey(portalZdo);
					string text5 = (string.IsNullOrEmpty(effectiveRequiredGlobalKey) ? PortalRulesLocalization.Translate("$sighsorry_portalrules_none") : StringExtensionMethods.RemoveRichTextTags(effectiveRequiredGlobalKey));
					__result = __result + "\n" + PortalRulesLocalization.Translate("$sighsorry_portalrules_hover_required_global_key", PortalRulesLocalization.Translate("$sighsorry_portalrules_key_alt"), text4, text5);
				}
			}
		}

		[HarmonyPatch(typeof(TeleportWorld), "Interact")]
		private static class ToggleModePatch
		{
			private static bool Prefix(TeleportWorld __instance, Humanoid human, bool hold, ref bool __result)
			{
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				if (hold || (Object)(object)human != (Object)(object)Player.m_localPlayer || !PublicPortalKinds.IsHandledPortal(__instance))
				{
					return true;
				}
				ZDO portalZdo = PublicPortalKinds.GetPortalZdo(__instance);
				if (portalZdo == null)
				{
					return true;
				}
				bool flag = PublicPortalConfig.ToggleAccessKey.Value.IsKeyHeld();
				bool flag2 = IsAdminPortal(portalZdo);
				if (flag2 && !PortalRulesPlugin.HasAdminDebugAccess)
				{
					Player localPlayer = Player.m_localPlayer;
					if (localPlayer != null)
					{
						((Character)localPlayer).Message((MessageType)2, PortalRulesLocalization.Translate("$sighsorry_portalrules_admin_portal_controls_require_admin_debug"), 0, (Sprite)null);
					}
					__result = true;
					return false;
				}
				bool flag3 = Input.GetKey((KeyCode)308) || Input.GetKey((KeyCode)307);
				if (flag2 && flag3)
				{
					AdminPortalOperations.OpenRequiredGlobalKeyInput(__instance);
					__result = true;
					return false;
				}
				if (flag2 && !flag)
				{
					TextInput instance = TextInput.instance;
					if (instance != null)
					{
						instance.RequestText((TextReceiver)(object)__instance, "$piece_portal_tag", 10);
					}
					__result = true;
					return false;
				}
				if (!flag)
				{
					return true;
				}
				if (!PublicPortalAccess.CanEditPortal(portalZdo))
				{
					Player localPlayer2 = Player.m_localPlayer;
					if (localPlayer2 != null)
					{
						((Character)localPlayer2).Message((MessageType)2, PortalRulesLocalization.Translate("$sighsorry_portalrules_access_cannot_be_changed"), 0, (Sprite)null);
					}
					__result = true;
					return false;
				}
				RequestAccessModeChange(portalZdo);
				__result = true;
				return false;
			}
		}

		private const int CycleAccessModeRequest = -1;

		private const float AccessModeRequestCooldownSeconds = 1f;

		private const float MaximumPortalInteractionDistance = 8f;

		private static readonly Dictionary<ZRpc, float> LastAccessModeRequestAt = new Dictionary<ZRpc, float>();

		internal static void Shutdown()
		{
			LastAccessModeRequestAt.Clear();
		}

		internal static bool IsAdminPortal(ZDO zdo)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if (zdo == null)
			{
				return false;
			}
			if (PublicPortalKinds.IsAdminPortalPrefab(zdo.GetPrefab()) || PublicPortalCatalog.IsAuthoritativeAdminPortal(zdo.m_uid))
			{
				return true;
			}
			if (PublicPortalCatalog.TryGetClientEntry(zdo.m_uid, out var entry))
			{
				return PublicPortalKinds.IsAdminPortalPrefab(entry.PrefabHash);
			}
			return false;
		}

		internal static string AccessModeLabel(PublicPortalAccessMode mode)
		{
			return PortalRulesLocalization.Translate(AccessModeToken(mode));
		}

		private static string AccessModeToken(PublicPortalAccessMode mode)
		{
			return mode switch
			{
				PublicPortalAccessMode.Personal => "$sighsorry_portalrules_access_mode_personal", 
				PublicPortalAccessMode.Admin => "$sighsorry_portalrules_access_mode_admin", 
				PublicPortalAccessMode.Public => "$sighsorry_portalrules_access_mode_public", 
				PublicPortalAccessMode.Invite => "$sighsorry_portalrules_access_mode_invite", 
				PublicPortalAccessMode.Clan => "$sighsorry_portalrules_access_mode_clan", 
				PublicPortalAccessMode.Tagged => "$sighsorry_portalrules_access_mode_tagged", 
				_ => "$sighsorry_portalrules_access_mode_personal", 
			};
		}

		private static PublicPortalAccessMode NextAccessModeCandidate(PublicPortalAccessMode mode, bool isAdminPortal)
		{
			if (isAdminPortal)
			{
				return mode switch
				{
					PublicPortalAccessMode.Admin => PublicPortalAccessMode.Public, 
					PublicPortalAccessMode.Public => PublicPortalAccessMode.Tagged, 
					PublicPortalAccessMode.Tagged => PublicPortalAccessMode.Admin, 
					_ => PublicPortalAccessMode.Public, 
				};
			}
			return mode switch
			{
				PublicPortalAccessMode.Personal => PublicPortalAccessMode.Admin, 
				PublicPortalAccessMode.Admin => PublicPortalAccessMode.Public, 
				PublicPortalAccessMode.Public => PublicPortalAccessMode.Invite, 
				PublicPortalAccessMode.Invite => PublicPortalAccessMode.Clan, 
				PublicPortalAccessMode.Clan => PublicPortalAccessMode.Tagged, 
				PublicPortalAccessMode.Tagged => PublicPortalAccessMode.Personal, 
				_ => PublicPortalAccessMode.Personal, 
			};
		}

		private static void RequestAccessModeChange(ZDO zdo)
		{
			//IL_003c: 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)
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)2, PortalRulesLocalization.Translate("$sighsorry_portalrules_access_change_server_unavailable"), 0, (Sprite)null);
				}
				return;
			}
			if (ZNet.instance.IsServer())
			{
				ShowAccessModeResult(TryApplyAccessModeChange(zdo.m_uid, -1, null, PortalRulesPlugin.IsAdmin, Player.m_debugMode, out var appliedMode, out var message), appliedMode, message);
				return;
			}
			ZRpc serverRPC = ZNet.instance.GetServerRPC();
			if (serverRPC == null)
			{
				Player localPlayer2 = Player.m_localPlayer;
				if (localPlayer2 != null)
				{
					((Character)localPlayer2).Message((MessageType)2, PortalRulesLocalization.Translate("$sighsorry_portalrules_access_change_connection_unavailable"), 0, (Sprite)null);
				}
			}
			else
			{
				serverRPC.Invoke("sighsorry.PortalRules.ChangeAccessMode.v4", new object[3]
				{
					zdo.m_uid,
					-1,
					Player.m_debugMode
				});
			}
		}

		private static void OnRemoteAccessModeChange(ZRpc rpc, ZDOID portalId, int accessMode, bool debugEnabled)
		{
			//IL_0039: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: 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)
			ZNet instance = ZNet.instance;
			if ((Object)(object)instance == (Object)null || !instance.IsServer())
			{
				return;
			}
			ZNetPeer val = PublicPortalData.FindPeer(instance, rpc);
			if (val == null || !val.IsReady() || ((ZDOID)(ref val.m_characterID)).IsNone())
			{
				SendAccessModeResult(rpc, portalId, success: false, PublicPortalAccessMode.Personal, new PortalRulesMessage("$sighsorry_portalrules_access_change_unauthenticated"));
				return;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (LastAccessModeRequestAt.TryGetValue(rpc, out var value) && realtimeSinceStartup - value < 1f)
			{
				SendAccessModeResult(rpc, portalId, success: false, PublicPortalAccessMode.Personal, new PortalRulesMessage("$sighsorry_portalrules_access_change_rate_limited"));
				return;
			}
			LastAccessModeRequestAt[rpc] = realtimeSinceStartup;
			if (!PublicPortalData.TryGetPeerOwner(val, out var owner))
			{
				SendAccessModeResult(rpc, portalId, success: false, PublicPortalAccessMode.Personal, new PortalRulesMessage("$sighsorry_portalrules_platform_identity_unverified"));
				return;
			}
			bool requesterIsAdmin = PublicPortalData.IsPeerAdmin(instance, val);
			PublicPortalAccessMode appliedMode;
			PortalRulesMessage message;
			bool flag = TryApplyAccessModeChange(portalId, accessMode, val, requesterIsAdmin, debugEnabled, out appliedMode, out message);
			if (!flag)
			{
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)$"Rejected portal access request from {owner.Id} for {portalId}: {message.Token}");
			}
			SendAccessModeResult(rpc, portalId, flag, appliedMode, message);
		}

		private static void OnAccessModeChangeResult(ZRpc rpc, ZPackage package)
		{
			//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)
			if ((Object)(object)ZNet.instance == (Object)null || ZNet.instance.IsServer() || rpc != ZNet.instance.GetServerRPC())
			{
				return;
			}
			ZDOID val;
			bool flag;
			int num;
			PortalRulesMessage message;
			try
			{
				val = package.ReadZDOID();
				flag = package.ReadBool();
				num = package.ReadInt();
				if (!PortalRulesMessage.TryRead(package, out message))
				{
					PortalRulesPlugin.PortalRulesLogger.LogWarning((object)"Rejected malformed portal access result from the server.");
					return;
				}
			}
			catch (Exception ex)
			{
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("Rejected malformed portal access result from the server: " + ex.Message));
				return;
			}
			if (((ZDOID)(ref val)).IsNone())
			{
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)"Rejected portal access result without a portal ID.");
				return;
			}
			if (!Enum.IsDefined(typeof(PublicPortalAccessMode), num))
			{
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)$"Rejected portal access result with unknown mode {num}.");
				return;
			}
			PublicPortalAccessMode accessMode = (PublicPortalAccessMode)num;
			if (flag)
			{
				PublicPortalCatalog.RequestRefresh(force: true);
			}
			ShowAccessModeResult(flag, accessMode, message);
		}

		private static bool TryApplyAccessModeChange(ZDOID portalId, int rawAccessMode, ZNetPeer? requesterPeer, bool requesterIsAdmin, bool requesterDebugEnabled, out PublicPortalAccessMode appliedMode, out PortalRulesMessage message)
		{
			//IL_005d: 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_00c0: 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_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			appliedMode = PublicPortalAccessMode.Personal;
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || ZDOMan.instance == null)
			{
				message = new PortalRulesMessage("$sighsorry_portalrules_server_not_ready");
				return false;
			}
			if (rawAccessMode != -1)
			{
				message = new PortalRulesMessage("$sighsorry_portalrules_access_change_invalid_operation");
				return false;
			}
			ZDO zDO = ZDOMan.instance.GetZDO(portalId);
			if (zDO == null || !zDO.IsValid() || !ZDOMan.instance.GetPortals().Contains(zDO) || !PublicPortalKinds.IsHandledPortal(zDO))
			{
				message = new PortalRulesMessage("$sighsorry_portalrules_destination_not_managed_portal");
				return false;
			}
			if (!TryValidatePortalInteraction(zDO, requesterPeer, out message))
			{
				return false;
			}
			if (!PublicPortalCatalog.TryGetAuthoritativeAccess(portalId, out var accessMode, out var owner))
			{
				PublicPortalCatalog.ObservePortal(zDO);
				if (!PublicPortalCatalog.TryGetAuthoritativeAccess(portalId, out accessMode, out owner))
				{
					message = new PortalRulesMessage("$sighsorry_portalrules_portal_missing_from_catalog");
					return false;
				}
			}
			bool flag = IsAdminPortal(zDO);
			if (flag && (!requesterIsAdmin || !requesterDebugEnabled))
			{
				message = new PortalRulesMessage("$sighsorry_portalrules_admin_portal_change_requires_admin_debug");
				return false;
			}
			PortalBuilder builder = new PortalBuilder("", "");
			if (!flag && (!PublicPortalCatalog.TryGetAuthoritativeBuilder(portalId, out builder) || !builder.IsValid))
			{
				message = new PortalRulesMessage("$sighsorry_portalrules_portal_builder_unverified");
				return false;
			}
			appliedMode = accessMode;
			string steamId;
			bool flag2 = ((requesterPeer != null) ? PublicPortalData.TryGetPeerSteamId64(requesterPeer, out steamId) : PublicPortalData.TryGetLocalSteamId64(out steamId)) && builder.IsValid && string.Equals(steamId, builder.AccountId, StringComparison.Ordinal);
			if (!flag && accessMode == PublicPortalAccessMode.Invite && !flag2)
			{
				message = new PortalRulesMessage("$sighsorry_portalrules_invite_access_change_builder_only");
				return false;
			}
			if (!flag && !flag2 && !(requesterIsAdmin && requesterDebugEnabled) && !ClanPortalAccess.IsRequesterInBuilderPrimaryClan(builder, requesterPeer))
			{
				message = new PortalRulesMessage("$sighsorry_portalrules_access_cannot_be_changed");
				return false;
			}
			if (!TryResolveNextAccessMode(accessMode, flag, requesterIsAdmin, flag2, builder, out PublicPortalAccessMode nextMode, out string authorizedClanId, out string authorizedClanName))
			{
				message = new PortalRulesMessage("$sighsorry_portalrules_no_eligible_access_mode");
				return false;
			}
			if (!PublicPortalCatalog.SetAuthoritativeAccess(zDO, nextMode, authorizedClanId))
			{
				message = new PortalRulesMessage("$sighsorry_portalrules_catalog_update_failed");
				return false;
			}
			appliedMode = nextMode;
			if (nextMode != accessMode)
			{
				PublicPortalModeChangeEffects.Broadcast(zDO.m_uid);
				PublicPortalTaggedConnections.RefreshConnections();
			}
			string text = AccessModeToken(nextMode);
			int remainingSeconds;
			if (nextMode == PublicPortalAccessMode.Clan && !string.IsNullOrWhiteSpace(authorizedClanName))
			{
				message = new PortalRulesMessage("$sighsorry_portalrules_access_changed_clan", text, authorizedClanName);
			}
			else if (!flag && nextMode == PublicPortalAccessMode.Public && PublicPortalCatalog.TryGetTemporaryPublicRemainingSeconds(zDO.m_uid, out remainingSeconds))
			{
				message = new PortalRulesMessage("$sighsorry_portalrules_access_changed_temporary", text, remainingSeconds.ToString(CultureInfo.InvariantCulture));
			}
			else
			{
				message = new PortalRulesMessage("$sighsorry_portalrules_access_changed", text);
			}
			return true;
		}

		private static bool TryResolveNextAccessMode(PublicPortalAccessMode currentMode, bool isAdminPortal, bool requesterIsAdmin, bool requesterIsBuilder, PortalBuilder builder, out PublicPortalAccessMode nextMode, out string authorizedClanId, out string authorizedClanName)
		{
			nextMode = currentMode;
			authorizedClanId = "";
			authorizedClanName = "";
			int num = (isAdminPortal ? 3 : 6);
			for (int i = 0; i < num; i++)
			{
				authorizedClanId = "";
				authorizedClanName = "";
				PublicPortalAccessMode publicPortalAccessMode = (nextMode = NextAccessModeCandidate(nextMode, isAdminPortal));
				if ((publicPortalAccessMode == PublicPortalAccessMode.Admin && !requesterIsAdmin) || (publicPortalAccessMode == PublicPortalAccessMode.Invite && (!requesterIsBuilder || !PublicPortalServerPolicy.TryGetInviteQuotaState(builder.AccountId, out var currentCount, out var effectiveLimit) || (effectiveLimit >= 0 && currentCount >= effectiveLimit))))
				{
					continue;
				}
				bool flag = !isAdminPortal;
				if (flag)
				{
					bool flag2 = (uint)(publicPortalAccessMode - 3) <= 1u;
					flag = flag2;
				}
				if (flag)
				{
					PortalClanMembership membership = default(PortalClanMembership);
					bool flag3 = ClanPortalAccess.IsServerRegistryAvailable && ClanPortalAccess.TryResolveBuilderMembership(builder, out membership) && membership.HasPrimaryClan;
					if (publicPortalAccessMode == PublicPortalAccessMode.Clan && (!flag3 || !PublicPortalServerPolicy.TryGetClanQuotaState(membership.PrimaryClanId, out var currentCount2, out var effectiveLimit2) || (effectiveLimit2 >= 0 && currentCount2 >= effectiveLimit2)))
					{
						continue;
					}
					if (flag3)
					{
						authorizedClanId = membership.PrimaryClanId;
						authorizedClanName = membership.PrimaryClanName;
					}
				}
				return true;
			}
			nextMode = currentMode;
			authorizedClanId = "";
			authorizedClanName = "";
			return false;
		}

		internal static bool TryValidatePortalInteraction(ZDO zdo, ZNetPeer? requesterPeer, out PortalRulesMessage message)
		{
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: 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_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			message = new PortalRulesMessage("$sighsorry_portalrules_move_closer_to_portal");
			if (zdo == null || !zdo.IsValid() || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || ZDOMan.instance == null || !ZDOMan.instance.GetPortals().Contains(zdo) || !PublicPortalKinds.IsHandledPortal(zdo))
			{
				message = new PortalRulesMessage("$sighsorry_portalrules_requested_portal_unavailable");
				return false;
			}
			Vector3 position;
			if (requesterPeer != null)
			{
				if (!PublicPortalData.TryGetAuthenticatedPeerCharacterPosition(requesterPeer, out position))
				{
					message = new PortalRulesMessage("$sighsorry_portalrules_active_character_unverified");
					return false;
				}
			}
			else
			{
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer == (Object)null)
				{
					message = new PortalRulesMessage("$sighsorry_portalrules_local_player_unverified");
					return false;
				}
				position = ((Component)localPlayer).transform.position;
			}
			Vector3 position2 = zdo.GetPosition();
			if (!IsFinite(position) || !IsFinite(position2) || Vector3.Distance(position, position2) > 8f)
			{
				return false;
			}
			message = PortalRulesMessage.Empty;
			return true;
		}

		private static bool IsFinite(Vector3 value)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//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)
			if (!float.IsNaN(value.x) && !float.IsInfinity(value.x) && !float.IsNaN(value.y) && !float.IsInfinity(value.y) && !float.IsNaN(value.z))
			{
				return !float.IsInfinity(value.z);
			}
			return false;
		}

		private static void SendAccessModeResult(ZRpc rpc, ZDOID portalId, bool success, PublicPortalAccessMode accessMode, PortalRulesMessage message)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			ZPackage val = new ZPackage();
			val.Write(portalId);
			val.Write(success);
			val.Write((int)accessMode);
			message.Write(val);
			rpc.Invoke("sighsorry.PortalRules.ChangeAccessModeResult.v5", new object[1] { val });
		}

		private static void ShowAccessModeResult(bool success, PublicPortalAccessMode accessMode, PortalRulesMessage message)
		{
			string text = ((!message.IsEmpty) ? message.Localize() : (success ? PortalRulesLocalization.Translate("$sighsorry_portalrules_access_changed", AccessModeLabel(accessMode)) : PortalRulesLocalization.Translate("$sighsorry_portalrules_access_change_failed")));
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer != null)
			{
				((Character)localPlayer).Message((MessageType)2, text, 0, (Sprite)null);
			}
		}

		private static void RefreshPeerIdentity(ZNet znet, ZRpc rpc)
		{
			if (!((Object)(object)znet == (Object)null) && znet.IsServer())
			{
				PublicPortalServerPolicy.SendQuotaState(PublicPortalData.FindPeer(znet, rpc), force: true);
			}
		}

		private static bool TryGetTemporaryPublicRemainingSeconds(ZDO zdo, out int remainingSeconds)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if (PublicPortalCatalog.TryGetTemporaryPublicRemainingSeconds(zdo.m_uid, out remainingSeconds))
			{
				return true;
			}
			long num = PublicPortalData.GetPublicExpiresAtUtcSeconds(zdo) - PublicPortalCatalog.GetEstimatedServerUtcNowSeconds();
			if (num <= 0)
			{
				remainingSeconds = 0;
				return false;
			}
			remainingSeconds = (int)Math.Min(2147483647L, num);
			return true;
		}

		private static string FormatPortalLimit(int limit)
		{
			if (limit >= 0)
			{
				return limit.ToString();
			}
			return "∞";
		}
	}
	internal static class PublicPortalKinds
	{
		internal const string WoodPortalPrefabName = "portal_wood";

		internal const string StonePortalPrefabName = "portal_stone";

		internal const string AdminWoodPortalPrefabName = "admin_portal_wood";

		internal const string AdminStonePortalPrefabName = "admin_portal_stone";

		private static readonly int WoodPortalHash = StringExtensionMethods.GetStableHashCode("portal_wood");

		private static readonly int StonePortalHash = StringExtensionMethods.GetStableHashCode("portal_stone");

		private static readonly int AdminWoodPortalHash = StringExtensionMethods.GetStableHashCode("admin_portal_wood");

		private static readonly int AdminStonePortalHash = StringExtensionMethods.GetStableHashCode("admin_portal_stone");

		internal static bool IsAdminPortalPrefab(int prefabHash)
		{
			if (prefabHash != AdminWoodPortalHash)
			{
				return prefabHash == AdminStonePortalHash;
			}
			return true;
		}

		internal static bool PrefabAllowsAllItems(int prefabHash)
		{
			if (IsAdminPortalPrefab(prefabHash))
			{
				return true;
			}
			GameObject val = (((Object)(object)ZNetScene.instance != (Object)null) ? ZNetScene.instance.GetPrefab(prefabHash) : null);
			TeleportWorld val2 = (((Object)(object)val != (Object)null) ? val.GetComponent<TeleportWorld>() : null);
			if ((Object)(object)val2 != (Object)null)
			{
				return val2.m_allowAllItems;
			}
			return false;
		}

		internal static bool IsHandledPortal(TeleportWorld portal)
		{
			if ((Object)(object)portal == (Object)null)
			{
				return false;
			}
			if (PublicPortalConfig.LimitToVanillaPortals.Value.IsOff())
			{
				return true;
			}
			string prefabName = Utils.GetPrefabName(((Component)portal).gameObject);
			switch (prefabName)
			{
			default:
				return prefabName == "admin_portal_stone";
			case "portal_wood":
			case "portal_stone":
			case "admin_portal_wood":
				return true;
			}
		}

		internal static bool IsHandledPortal(ZDO zdo)
		{
			if (zdo == null)
			{
				return false;
			}
			if (PublicPortalConfig.LimitToVanillaPortals.Value.IsOff())
			{
				return true;
			}
			int prefab = zdo.GetPrefab();
			if (prefab != WoodPortalHash && prefab != StonePortalHash)
			{
				return IsAdminPortalPrefab(prefab);
			}
			return true;
		}

		internal static ZDO? GetPortalZdo(TeleportWorld portal)
		{
			if ((Object)(object)portal == (Object)null)
			{
				return null;
			}
			ZNetView component = ((Component)portal).GetComponent<ZNetView>();
			if (!((Object)(object)component != (Object)null) || !component.IsValid())
			{
				return null;
			}
			return component.GetZDO();
		}
	}
	[HarmonyPatch]
	internal static class PublicPortalMap
	{
		[HarmonyPatch(typeof(Minimap), "UpdateMap")]
		private static class PortalMapWheelZoomPatch
		{
			private const int MouseWheelClampSearchWindow = 12;

			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				MethodInfo getMouseScrollWheel = AccessTools.DeclaredMethod(typeof(ZInput), "GetMouseScrollWheel", (Type[])null, (Type[])null);
				MethodInfo clampFloat = AccessTools.DeclaredMethod(typeof(Mathf), "Clamp", new Type[3]
				{
					typeof(float),
					typeof(float),
					typeof(float)
				}, (Type[])null);
				MethodInfo clampPortalMapMouseWheel = AccessTools.DeclaredMethod(typeof(PublicPortalMap), "ClampPortalMapMouseWheel", (Type[])null, (Type[])null);
				int clampSearchRemaining = 0;
				bool foundMinimumClamp = false;
				bool foundMaximumClamp = false;
				bool replaced = false;
				foreach (CodeInstruction instruction in instructions)
				{
					if (!replaced && CodeInstructionExtensions.Calls(instruction, getMouseScrollWheel))
					{
						clampSearchRemaining = 12;
						foundMinimumClamp = false;
						foundMaximumClamp = false;
					}
					else if (!replaced && clampSearchRemaining > 0)
					{
						if (instruction.opcode == OpCodes.Ldc_R4 && instruction.operand is float num)
						{
							foundMinimumClamp = foundMinimumClamp || num == -0.05f;
							foundMaximumClamp = foundMaximumClamp || num == 0.05f;
						}
						else if (foundMinimumClamp && foundMaximumClamp && CodeInstructionExtensions.Calls(instruction, clampFloat))
						{
							instruction.operand = clampPortalMapMouseWheel;
							replaced = true;
						}
						clampSearchRemaining--;
					}
					yield return instruction;
				}
				if (!replaced)
				{
					PortalRulesPlugin.PortalRulesLogger.LogWarning((object)"Could not patch the portal-map mouse-wheel zoom rate; using Valheim's default rate.");
				}
			}
		}

		[HarmonyPatch(typeof(TeleportWorldTrigger), "OnTriggerEnter")]
		private static class PortalTriggerPatch
		{
			private static bool Prefix(TeleportWorldTrigger __instance, Collider colliderIn)
			{
				TeleportWorld componentInParent = ((Component)__instance).GetComponentInParent<TeleportWorld>();
				if (!IsLocalPlayer(colliderIn))
				{
					return true;
				}
				if (!PublicPortalKinds.IsHandledPortal(componentInParent))
				{
					return true;
				}
				if (IsMapSelectionPortal(componentInParent))
				{
					PublicPortalMapController.Instance.Begin(componentInParent, ((Component)__instance).GetComponent<Collider>(), colliderIn);
					return false;
				}
				PublicPortalTeleportService.TryBeginConnectedTeleport(componentInParent);
				return false;
			}
		}

		[HarmonyPatch(typeof(TeleportWorld), "HaveTarget")]
		private static class HaveTargetPatch
		{
			private static bool Prefix(TeleportWorld __instance, ref bool __result)
			{
				if (!IsMapSelectionPortal(__instance))
				{
					return true;
				}
				__result = true;
				return false;
			}
		}

		[HarmonyPatch(typeof(TeleportWorld), "TargetFound")]
		private static class TargetFoundPatch
		{
			private static bool Prefix(TeleportWorld __instance, ref bool __result)
			{
				if (!IsMapSelectionPortal(__instance))
				{
					return true;
				}
				__result = true;
				return false;
			}
		}

		[HarmonyPatch(typeof(Minimap), "SetMapMode")]
		private static class CloseSelectionOnMapClosePatch
		{
			private static void Postfix(MapMode mode)
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				PublicPortalMapController.Instance.OnMapModeChanged(mode);
			}
		}

		[HarmonyPatch(typeof(Minimap), "OnMapLeftClick")]
		private static class PortalMapLeftClickPatch
		{
			private static bool Prefix(Minimap __instance)
			{
				if (!PublicPortalMapController.Instance.IsSelecting)
				{
					return true;
				}
				PublicPortalMapController.Instance.HandleLeftClick(__instance);
				return false;
			}
		}

		[HarmonyPatch(typeof(Minimap), "OnMapRightClick")]
		private static class PortalMapRightClickPatch
		{
			private static bool Prefix(Minimap __instance)
			{
				if (!PublicPortalMapController.Instance.IsSelecting)
				{
					return true;
				}
				PublicPortalMapController.Instance.HandleRightClick(__instance);
				return false;
			}
		}

		private static bool IsLocalPlayer(Collider collider)
		{
			Player component = ((Component)collider).GetComponent<Player>();
			if ((Object)(object)component != (Object)null)
			{
				return (Object)(object)Player.m_localPlayer == (Object)(object)component;
			}
			return false;
		}

		private static bool IsMapSelectionPortal(TeleportWorld portal)
		{
			if ((Object)(object)portal == (Object)null || PublicPortalConfig.EnablePortalMap.Value.IsOff() || !PublicPortalKinds.IsHandledPortal(portal))
			{
				return false;
			}
			ZDO portalZdo = PublicPortalKinds.GetPortalZdo(portal);
			if (portalZdo != null)
			{
				return PublicPortalCatalog.GetEffectiveAccessMode(portalZdo) != PublicPortalAccessMode.Tagged;
			}
			return false;
		}

		private static float ClampPortalMapMouseWheel(float value, float minimum, float maximum)
		{
			float num = Mathf.Clamp(value, minimum, maximum);
			if (!PublicPortalMapController.Instance.IsSelecting)
			{
				return num;
			}
			int num2 = Mathf.Clamp(PublicPortalConfig.PortalMapWheelZoomMultiplier.Value, 1, 10);
			return num * (float)num2;
		}
	}
	internal sealed class PublicPortalMapController
	{
		private delegate Vector3 ScreenToWorldPointDelegate(Minimap minimap, Vector3 screenPoint);

		private delegate bool TakeInputDelegate(PlayerController controller, bool look);

		private readonly struct FavoriteFareState : IEquatable<FavoriteFareState>
		{
			private readonly PublicPortalTravelCostScope _scope;

			private readonly int _baseCoinCost;

			private readonly float _includedDistanceMeters;

			private readonly float _coinsPerKilometer;

			private readonly int _localCoinCount;

			private readonly bool _itemsBlocked;

			private readonly bool _noTeleportVisualAvailable;

			private readonly string _inviteCooldownState;

			internal FavoriteFareState(PublicPortalTravelCostScope scope, int baseCoinCost, float includedDistanceMeters, float coinsPerKilometer, int localCoinCount, bool itemsBlocked, bool noTeleportVisualAvailable, string inviteCooldownState)
			{
				_scope = scope;
				_baseCoinCost = baseCoinCost;
				_includedDistanceMeters = includedDistanceMeters;
				_coinsPerKilometer = coinsPerKilometer;
				_localCoinCount = localCoinCount;
				_itemsBlocked = itemsBlocked;
				_noTeleportVisualAvailable = noTeleportVisualAvailable;
				_inviteCooldownState = inviteCooldownState;
			}

			public bool Equals(FavoriteFareState other)
			{
				if (_scope == other._scope && _baseCoinCost == other._baseCoinCost)
				{
					float includedDistanceMeters = _includedDistanceMeters;
					if (includedDistanceMeters.Equals(other._includedDistanceMeters))
					{
						includedDistanceMeters = _coinsPerKilometer;
						if (includedDistanceMeters.Equals(other._coinsPerKilometer) && _localCoinCount == other._localCoinCount && _itemsBlocked == other._itemsBlocked && _noTeleportVisualAvailable == other._noTeleportVisualAvailable)
						{
							return string.Equals(_inviteCooldownState, other._inviteCooldownState, StringComparison.Ordinal);
						}
					}
				}
				return false;
			}
		}

		private const string AvailablePortalsHintName = "PortalRulesAvailablePortals";

		private const string AddPinHintName = "AddPin";

		private const string HintMainKeyColor = "#FFA500";

		private const float FavoriteFareStateCheckIntervalSeconds = 0.2f;

		private static ScreenToWorldPointDelegate? ScreenToWorldPoint = CreateScreenToWorldPointDelegate();

		private static readonly TakeInputDelegate? TakeInput = CreateTakeInputDelegate();

		public static readonly PublicPortalMapController Instance = new PublicPortalMapController();

		private readonly PublicPortalPinController _pins = new PublicPortalPinController();

		private readonly PublicPortalFavoritePanel _favorites = new PublicPortalFavoritePanel();

		private bool _sourceAllowsAllItems;

		private ZDOID _sourcePortalId = ZDOID.None;

		private PublicPortalCatalogEntry? _sourcePortal;

		private Collider? _sourceTriggerCollider;

		private Collider? _playerCollider;

		private float _lostSourceAreaAt = -1f;

		private bool _showingAccessiblePins;

		private bool _showEmptyMessageWhenCatalogArrives;

		private bool _lastAdminDebugMapAccess;

		private Minimap? _availablePortalsHintOwner;

		private GameObject? _availablePortalsHint;

		private TMP_Text? _availablePortalsHintLabel;

		private float _nextFavoriteFareStateCheckAt = -1f;

		private FavoriteFareState? _favoriteFareState;

		public bool IsSelecting { get; private set; }

		private PublicPortalMapController()
		{
			//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)
			PublicPortalCatalog.Updated += OnCatalogUpdated;
		}

		public void Begin(TeleportWorld sourcePortal, Collider? sourceTriggerCollider, Collider playerCollider)
		{
			//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_0075: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Minimap.instance == (Object)null || ZDOMan.instance == null || (Object)(object)Player.m_localPlayer == (Object)null || (Object)(object)sourcePortal == (Object)null)
			{
				return;
			}
			ZDO portalZdo = PublicPortalKinds.GetPortalZdo(sourcePortal);
			if (portalZdo != null)
			{
				PublicPortalTeleportService.CancelPending();
				ZDOID sourcePortalId = portalZdo.m_uid;
				PublicPortalTeleportService.AuthorizeMapOpen(sourcePortalId, delegate
				{
					//IL_0007: Unknown result type (might be due to invalid IL or missing references)
					BeginAuthorized(sourcePortalId, sourcePortal, sourceTriggerCollider, playerCollider);
				});
			}
		}

		private void BeginAuthorized(ZDOID authorizedSourcePortalId, TeleportWorld sourcePortal, Collider? sourceTriggerCollider, Collider playerCollider)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Minimap.instance == (Object)null || ZDOMan.instance == null || (Object)(object)Player.m_localPlayer == (Object)null || (Object)(object)sourcePortal == (Object)null || (Object)(object)playerCollider == (Object)null || (Object)(object)((Component)playerCollider).GetComponent<Player>() != (Object)(object)Player.m_localPlayer)
			{
				return;
			}
			ZDO portalZdo = PublicPortalKinds.GetPortalZdo(sourcePortal);
			if (portalZdo != null && !(portalZdo.m_uid != authorizedSourcePortalId))
			{
				IsSelecting = true;
				_sourceAllowsAllItems = sourcePortal.m_allowAllItems;
				_sourcePortalId = authorizedSourcePortalId;
				_sourcePortal = ResolveSourcePortalEntry(sourcePortal, portalZdo);
				_sourceTriggerCollider = sourceTriggerCollider;
				_playerCollider = playerCollider;
				_lostSourceAreaAt = -1f;
				OpenMapAt(((Component)sourcePortal).transform.position);
				InventoryGui instance = InventoryGui.instance;
				if (instance != null)
				{
					instance.Hide();
				}
				SetAccessiblePortalPinsVisible(visible: true, showMessage: false);
			}
		}

		public void Tick()
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Invalid comparison between Unknown and I4
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			Minimap instance = Minimap.instance;
			if ((Object)(object)instance == (Object)null)
			{
				DestroyAvailablePortalsHint();
				if (IsSelecting || _showingAccessiblePins || _pins.Count > 0 || _favorites.IsVisible)
				{
					End();
				}
				return;
			}
			if ((int)instance.m_mode != 2)
			{
				DestroyAvailablePortalsHint();
				if (IsSelecting || _showingAccessiblePins)
				{
					End();
				}
				return;
			}
			bool hasAdminDebugAccess = PortalRulesPlugin.HasAdminDebugAccess;
			if (_showingAccessiblePins && _lastAdminDebugMapAccess != hasAdminDebugAccess)
			{
				_lastAdminDebugMapAccess = hasAdminDebugAccess;
				RefreshVisiblePins(requestServerRefresh: false);
			}
			if (PublicPortalConfig.EnablePortalMap.Value.IsOn() && PublicPortalConfig.ToggleAccessiblePortalsKey.Value.IsKeyDown() && CanProcessMapShortcutInput())
			{
				ToggleAccessiblePortalPins();
			}
			UpdateAvailablePortalsHint(instance);
			_pins.UpdateTravelBadges(IsSelecting, _sourcePortal, AllowsAllItemsForCurrentMapTrip());
			RefreshFavoriteFareStateIfChanged();
			if (IsSelecting && !(PublicPortalConfig.AutoCloseGraceSeconds.Value <= 0f) && !((Object)(object)Player.m_localPlayer == (Object)null))
			{
				if (IsInsideSourceTrigger())
				{
					_lostSourceAreaAt = -1f;
				}
				else if (_lostSourceAreaAt < 0f)
				{
					_lostSourceAreaAt = Time.time;
				}
				else if (Time.time - _lostSourceAreaAt >= PublicPortalConfig.AutoCloseGraceSeconds.Value)
				{
					Minimap.instance.SetMapMode((MapMode)1);
					End();
				}
			}
		}

		private static TakeInputDelegate? CreateTakeInputDelegate()
		{
			try
			{
				MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(PlayerController), "TakeInput", new Type[1] { typeof(bool) }, (Type[])null);
				return (methodInfo == null) ? null : AccessTools.MethodDelegate<TakeInputDelegate>(methodInfo, (object)null, false);
			}
			catch
			{
				return null;
			}
		}

		private static ScreenToWorldPointDelegate? CreateScreenToWorldPointDelegate()
		{
			try
			{
				MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(Minimap), "ScreenToWorldPoint", new Type[1] { typeof(Vector3) }, (Type[])null);
				if (methodInfo == null)
				{
					PortalRulesPlugin.PortalRulesLogger.LogWarning((object)"Minimap.ScreenToWorldPoint was not found; PortalRules map pin clicking is disabled.");
					return null;
				}
				return AccessTools.MethodDelegate<ScreenToWorldPointDelegate>(methodInfo, (object)null, false);
			}
			catch (Exception ex)
			{
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("Could not bind Minimap.ScreenToWorldPoint; PortalRules map pin clicking is disabled: " + ex.Message));
				return null;
			}
		}

		private static bool CanProcessMapShortcutInput()
		{
			if (TakeInput == null || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				return false;
			}
			PlayerController component = ((Component)Player.m_localPlayer).GetComponent<PlayerController>();
			if ((Object)(object)component != (Object)null)
			{
				return TakeInput(component, look: false);
			}
			return false;
		}

		public void OnMapModeChanged(MapMode mode)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			if ((int)mode == 2)
			{
				if (!IsSelecting && PublicPortalConfig.EnablePortalMap.Value.IsOn())
				{
					SetAccessiblePortalPinsVisible(visible: true, showMessage: false);
				}
			}
			else
			{
				End();
			}
		}

		public void End()
		{
			//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)
			DestroyAvailablePortalsHint();
			if (IsSelecting || _showingAccessiblePins || _pins.Count != 0 || _favorites.IsVisible)
			{
				IsSelecting = false;
				_sourcePortalId = ZDOID.None;
				_sourcePortal = null;
				PublicPortalTeleportService.CancelPending();
				_sourceTriggerCollider = null;
				_playerCollider = null;
				_lostSourceAreaAt = -1f;
				_favoriteFareState = null;
				_nextFavoriteFareStateCheckAt = -1f;
				SetAccessiblePortalPinsVisible(visible: false, showMessage: false);
			}
		}

		public void HandleLeftClick(Minimap minimap)
		{
			PublicPortalCatalogEntry? publicPortalCatalogEntry = FindClickedPortal(minimap);
			if (publicPortalCatalogEntry.HasValue)
			{
				TryTeleportTo(publicPortalCatalogEntry.Value);
			}
		}

		public void HandleRightClick(Minimap minimap)
		{
			PublicPortalCatalogEntry? publicPortalCatalogEntry = FindClickedPortal(minimap);
			if (publicPortalCatalogEntry.HasValue)
			{
				ToggleFavorite(publicPortalCatalogEntry.Value);
				RefreshFavorites();
			}
		}

		private void RefreshFavorites()
		{
			_favorites.Refresh(_sourcePortal, ItemsBlockedForCurrentMapTrip(), _pins.Portals, TryTeleportTo, RemoveFavorite, FocusFavorite);
			_favoriteFareState = (_favorites.IsCollapsed ? ((FavoriteFareState?)null) : new FavoriteFareState?(CaptureFavoriteFareState()));
		}

		internal void RefreshFavoritePanelFromPreference()
		{
			if (IsSelecting && _favorites.IsVisible)
			{
				RefreshFavorites();
			}
		}

		private void RefreshFavoriteFareStateIfChanged()
		{
			if (!IsSelecting || !_favorites.IsVisible || _favorites.IsCollapsed)
			{
				_favoriteFareState = null;
				_nextFavoriteFareStateCheckAt = -1f;
				return;
			}
			float unscaledTime = Time.unscaledTime;
			if (!(_nextFavoriteFareStateCheckAt >= 0f) || !(unscaledTime < _nextFavoriteFareStateCheckAt))
			{
				_nextFavoriteFareStateCheckAt = unscaledTime + 0.2f;
				FavoriteFareState favoriteFareState = CaptureFavoriteFareState();
				if (!_favoriteFareState.HasValue)
				{
					_favoriteFareState = favoriteFareState;
				}
				else if (!_favoriteFareState.Value.Equals(favoriteFareState))
				{
					RefreshFavorites();
				}
			}
		}

		private FavoriteFareState CaptureFavoriteFareState()
		{
			bool flag = ItemsBlockedForCurrentMapTrip();
			Sprite sprite;
			Color color;
			Material material;
			bool noTeleportVisualAvailable = !flag || PublicPortalTravelCost.TryGetNoTeleportVisual(out sprite, out color, out material);
			return new FavoriteFareState(PublicPortalConfig.TravelCostScope.Value, PublicPortalConfig.BaseCoinCost.Value, PublicPortalConfig.BaseFareIncludedDistanceMeters.Value, PublicPortalConfig.CoinsPerKilometer.Value, PublicPortalTravelCost.IsEnabled ? PublicPortalTravelCost.GetLocalCoinCount() : 0, flag, noTeleportVisualAvailable, GetFavoriteInviteCooldownDisplayState());
		}

		private string GetFavoriteInviteCooldownDisplayState()
		{
			List<string> favoriteIds = PublicPortalData.ReadFavorites();
			long remainingSeconds;
			return string.Join("|", from portal in _pins.Portals.Where((PublicPortalCatalogEntry portal) => favoriteIds.Contains(portal.FavoriteId) && portal.AccessMode == PublicPortalAccessMode.Invite).OrderBy<PublicPortalCatalogEntry, string>((PublicPortalCatalogEntry portal) => portal.FavoriteId, StringComparer.Ordinal)
				select (!InviteTravelCooldownStore.TryGetInviteArrivalCooldownRemaining(portal, out remainingSeconds)) ? (portal.FavoriteId + ":-") : (portal.FavoriteId + ":" + InviteTravelCooldownStore.FormatRemaining(remainingSeconds)));
		}

		private void TryTeleportTo(PublicPortalCatalogEntry portal)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			if (InviteTravelCooldownStore.TryGetInviteArrivalCooldownRemaining(portal, out var remainingSeconds))
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)2, PortalRulesLocalization.Translate("$sighsorry_portalrules_invite_arrival_cooldown_remaining", InviteTravelCooldownStore.FormatRemaining(remainingSeconds)), 0, (Sprite)null);
				}
			}
			else
			{
				PublicPortalTeleportService.TeleportTo(portal, _sourcePortalId, _sourceAllowsAllItems, End);
			}
		}

		private bool AllowsAllItemsForCurrentMapTrip()
		{
			if (IsSelecting)
			{
				return _sourceAllowsAllItems;
			}
			return false;
		}

		private bool ItemsBlockedForCurrentMapTrip()
		{
			if (IsSelecting && !AllowsAllItemsForCurrentMapTrip() && (Object)(object)Player.m_localPlayer != (Object)null)
			{
				return !((Humanoid)Player.m_localPlayer).IsTeleportable();
			}
			return false;
		}

		private void ToggleAccessiblePortalPins()
		{
			SetAccessiblePortalPinsVisible(!_showingAccessiblePins, showMessage: true);
		}

		private void SetAccessiblePortalPinsVisible(bool visible, bool showMessage)
		{
			if (!visible)
			{
				_showingAccessiblePins = false;
				_showEmptyMessageWhenCatalogArrives = false;
				_pins.Clear();
				_favorites.Destroy();
				return;
			}
			_showingAccessiblePins = true;
			_lastAdminDebugMapAccess = PortalRulesPlugin.HasAdminDebugAccess;
			_showEmptyMessageWhenCatalogArrives = showMessage && !PublicPortalCatalog.HasSnapshot;
			RefreshVisiblePins(requestServerRefresh: true);
			if (_pins.Count == 0 && PublicPortalCatalog.HasSnapshot && showMessage)
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)2, PortalRulesLocalization.Translate("$sighsorry_portalrules_no_accessible_portals"), 0, (Sprite)null);
				}
			}
		}

		private PublicPortalCatalogEntry? FindClickedPortal(Minimap minimap)
		{
			//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_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 (ScreenToWorldPoint == null)
			{
				return null;
			}
			try
			{
				Vector3 worldPoint = ScreenToWorldPoint(minimap, ZInput.mousePosition);
				return _pins.FindClosest(worldPoint);
			}
			catch (Exception ex)
			{
				ScreenToWorldPoint = null;
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("Could not convert the map cursor to world coordinates; PortalRules map pin clicking is disabled: " + ex.Message));
				return null;
			}
		}

		private static void OpenMapAt(Vector3 position)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Minimap.instance == (Object)null))
			{
				bool noMap = Game.m_noMap;
				Game.m_noMap = false;
				Minimap.instance.ShowPointOnMap(position);
				Game.m_noMap = noMap;
			}
		}

		private static PublicPortalCatalogEntry ResolveSourcePortalEntry(TeleportWorld sourcePortal, ZDO sourceZdo)
		{
			//IL_0001: 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_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if (PublicPortalCatalog.TryGetClientEntry(sourceZdo.m_uid, out var entry))
			{
				return entry;
			}
			return new PublicPortalCatalogEntry(sourceZdo.m_uid, "", sourceZdo.GetPrefab(), sourcePortal.m_allowAllItems, ((Component)sourcePortal).transform.position, ((Component)sourcePortal).transform.rotation, sourceZdo.GetString(ZDOVars.s_tag, ""), PublicPortalCatalog.GetEffectiveAccessMode(sourceZdo), PublicPortalCatalog.GetEffectiveOwner(sourceZdo), 0, 0, 0, 0, 0, 0L, 0L);
		}

		private void FocusFavorite(PublicPortalCatalogEntry portal)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Invalid comparison between Unknown and I4
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			if (IsSelecting && !((Object)(object)Minimap.instance == (Object)null) && (int)Minimap.instance.m_mode == 2)
			{
				OpenMapAt(portal.Position);
			}
		}

		private bool IsInsideSourceTrigger()
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_sourceTriggerCollider == (Object)null || (Object)(object)_playerCollider == (Object)null)
			{
				return false;
			}
			if (!_sourceTriggerCollider.enabled || !_playerCollider.enabled)
			{
				return false;
			}
			Bounds bounds = _sourceTriggerCollider.bounds;
			if (((Bounds)(ref bounds)).Intersects(_playerCollider.bounds))
			{
				return true;
			}
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				return false;
			}
			Vector3 position = ((Component)Player.m_localPlayer).transform.position;
			return Vector3.Distance(_sourceTriggerCollider.ClosestPoint(position), position) <= 0.05f;
		}

		private void ToggleFavorite(PublicPortalCatalogEntry target)
		{
			if (!PublicPortalData.TryNormalizeFavoriteId(target.FavoriteId, out string normalizedFavoriteId))
			{
				return;
			}
			List<string> list = PublicPortalData.ReadFavorites();
			string text;
			if (list.Remove(normalizedFavoriteId))
			{
				text = PortalRulesLocalization.Translate("$sighsorry_portalrules_favorite_removed");
			}
			else
			{
				bool flag = false;
				if (list.Count >= 10)
				{
					HashSet<string> availableFavoriteIds = new HashSet<string>(StringComparer.Ordinal);
					foreach (PublicPortalCatalogEntry portal in _pins.Portals)
					{
						if (!string.IsNullOrWhiteSpace(portal.FavoriteId))
						{
							availableFavoriteIds.Add(portal.FavoriteId);
						}
					}
					int num = list.FindIndex((string candidate) => !availableFavoriteIds.Contains(candidate));
					if (num >= 0)
					{
						list.RemoveAt(num);
						flag = true;
					}
				}
				if (list.Count >= 10)
				{
					Player localPlayer = Player.m_localPlayer;
					if (localPlayer != null)
					{
						((Character)localPlayer).Message((MessageType)1, PortalRulesLocalization.Translate("$sighsorry_portalrules_favorite_limit", 10.ToString()), 0, (Sprite)null);
					}
					return;
				}
				list.Add(normalizedFavoriteId);
				text = (flag ? PortalRulesLocalization.Translate("$sighsorry_portalrules_favorite_added_replaced_unavailable") : PortalRulesLocalization.Translate("$sighsorry_portalrules_favorite_added"));
			}
			PublicPortalData.WriteFavorites(list);
			Player localPlayer2 = Player.m_localPlayer;
			if (localPlayer2 != null)
			{
				((Character)localPlayer2).Message((MessageType)1, text, 0, (Sprite)null);
			}
		}

		private void RemoveFavorite(PublicPortalCatalogEntry target)
		{
			if (!PublicPortalData.TryNormalizeFavoriteId(target.FavoriteId, out string normalizedFavoriteId))
			{
				return;
			}
			List<string> list = PublicPortalData.ReadFavorites();
			if (list.Remove(normalizedFavoriteId))
			{
				PublicPortalData.WriteFavorites(list);
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)1, PortalRulesLocalization.Translate("$sighsorry_portalrules_favorite_removed"), 0, (Sprite)null);
				}
				RefreshFavorites();
			}
		}

		private void UpdateAvailablePortalsHint(Minimap minimap)
		{
			//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_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			KeyboardShortcut value = PublicPortalConfig.ToggleAccessiblePortalsKey.Value;
			if (!PublicPortalConfig.EnablePortalMap.Value.IsOn() || (int)((KeyboardShortcut)(ref value)).MainKey == 0 || PlatformPrefs.GetInt("KeyHints", 1) != 1 || !((Object)(object)minimap.m_largeRoot != (Object)null) || !minimap.m_largeRoot.activeInHierarchy)
			{
				HideAvailablePortalsHint();
				return;
			}
			if ((Object)(object)_availablePortalsHintOwner != (Object)(object)minimap || (Object)(object)_availablePortalsHint == (Object)null)
			{
				BuildAvailablePortalsHint(minimap);
			}
			if (!((Object)(object)_availablePortalsHint == (Object)null) && !((Object)(object)_availablePortalsHintLabel == (Object)null))
			{
				if (!_availablePortalsHint.activeSelf)
				{
					_availablePortalsHint.SetActive(true);
					MarkAvailablePortalsHintLayoutForRebuild();
				}
				string text = PortalRulesLocalization.Translate(_showingAccessiblePins ? "$sighsorry_portalrules_hint_hide_available_portals" : "$sighsorry_portalrules_hint_show_available_portals", FormatHintShortcut(value));
				if (!string.Equals(_availablePortalsHintLabel.text, text, StringComparison.Ordinal))
				{
					_availablePortalsHintLabel.text = text;
					MarkAvailablePortalsHintLayoutForRebuild();
				}
			}
		}

		private void BuildAvailablePortalsHint(Minimap minimap)
		{
			DestroyAvailablePortalsHint();
			GameObject largeRoot = minimap.m_largeRoot;
			Transform val = ((largeRoot != null) ? largeRoot.transform.Find("KeyHints/keyboard_hints") : null);
			Transform val2 = ((val != null) ? val.Find("AddPin") : null);
			if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null)
			{
				return;
			}
			Transform val3 = val.Find("PortalRulesAvailablePortals");
			GameObject val4 = (((Object)(object)val3 != (Object)null) ? ((Component)val3).gameObject : Object.Instantiate<GameObject>(((Component)val2).gameObject, val, false));
			((Object)val4).name = "PortalRulesAvailablePortals";
			int num = val2.GetSiblingIndex();
			if (val4.transform.GetSiblingIndex() < num)
			{
				num--;
			}
			val4.transform.SetSiblingIndex(Mathf.Max(0, num));
			Transform val5 = val4.transform.Find("keyboard_hint");
			if ((Object)(object)val5 != (Object)null)
			{
				((Component)val5).gameObject.SetActive(false);
			}
			Transform obj = val4.transform.Find("Label");
			TMP_Text val6 = ((obj != null) ? ((Component)obj).GetComponent<TMP_Text>() : null) ?? val4.GetComponentInChildren<TMP_Text>(true);
			if ((Object)(object)val6 == (Object)null)
			{
				if ((Object)(object)val3 == (Object)null)
				{
					Object.Destroy((Object)(object)val4);
				}
				return;
			}
			_availablePortalsHintOwner = minimap;
			_availablePortalsHint = val4;
			_availablePortalsHintLabel = val6;
			val6.richText = true;
			val4.SetActive(true);
			MarkAvailablePortalsHintLayoutForRebuild();
		}

		private void HideAvailablePortalsHint()
		{
			if ((Object)(object)_availablePortalsHint != (Object)null && _availablePortalsHint.activeSelf)
			{
				_availablePortalsHint.SetActive(false);
				MarkAvailablePortalsHintLayoutForRebuild();
			}
		}

		private void DestroyAvailablePortalsHint()
		{
			if ((Object)(object)_availablePortalsHint != (Object)null)
			{
				Object.Destroy((Object)(object)_availablePortalsHint);
			}
			_availablePortalsHintOwner = null;
			_availablePortalsHint = null;
			_availablePortalsHintLabel = null;
		}

		private void MarkAvailablePortalsHintLayoutForRebuild()
		{
			GameObject? availablePortalsHint = _availablePortalsHint;
			Transform obj = ((availablePortalsHint != null) ? availablePortalsHint.transform.parent : null);
			RectTransform val = (RectTransform)(object)((obj is RectTransform) ? obj : null);
			if (val != null)
			{
				LayoutRebuilder.MarkLayoutForRebuild(val);
			}
		}

		private static string FormatHintShortcut(KeyboardShortcut shortcut)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			List<string> list = ((KeyboardShortcut)(ref shortcut)).Modifiers.Select(FormatHintKey).ToList();
			list.Add("<color=#FFA500>" + FormatHintKey(((KeyboardShortcut)(ref shortcut)).MainKey) + "</color>");
			return string.Join(" + ", list);
		}

		private unsafe static string FormatHintKey(KeyCode key)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected I4, but got Unknown
			string text;
			switch (key - 303)
			{
			case 0:
			case 1:
				text = PortalRulesLocalization.Translate("$sighsorry_portalrules_key_shift");
				break;
			case 2:
			case 3:
				text = PortalRulesLocalization.Translate("$sighsorry_portalrules_key_control");
				break;
			case 4:
			case 5:
				text = PortalRulesLocalization.Translate("$sighsorry_portalrules_key_alt");
				break;
			default:
				text = ((object)(*(KeyCode*)(&key))/*cast due to .constrained prefix*/).ToString();
				break;
			}
			return StringExtensionMethods.RemoveRichTextTags(text);
		}

		private void OnCatalogUpdated()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Invalid comparison between Unknown and I4
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if (!_showingAccessiblePins || (Object)(object)Minimap.instance == (Object)null || (int)Minimap.instance.m_mode != 2)
			{
				return;
			}
			if (IsSelecting)
			{
				if (!PublicPortalCatalog.TryGetClientEntry(_sourcePortalId, out var entry) || !PublicPortalAccess.CanUsePortal(entry))
				{
					Player localPlayer = Player.m_localPlayer;
					if (localPlayer != null)
					{
						((Character)localPlayer).Message((MessageType)2, PortalRulesLocalization.Translate("$sighsorry_portalrules_source_portal_no_longer_accessible"), 0, (Sprite)null);
					}
					Minimap.instance.SetMapMode((MapMode)1);
					End();
					return;
				}
				_sourcePortal = entry;
			}
			RefreshVisiblePins(requestServerRefresh: false);
			if (_showEmptyMessageWhenCatalogArrives && _pins.Count == 0)
			{
				Player localPlayer2 = Player.m_localPlayer;
				if (localPlayer2 != null)
				{
					((Character)localPlayer2).Message((MessageType)2, PortalRulesLocalization.Translate("$sighsorry_portalrules_no_accessible_portals"), 0, (Sprite)null);
				}
			}
			_showEmptyMessageWhenCatalogArrives = false;
		}

		private void RefreshVisiblePins(bool requestServerRefresh)
		{
			_pins.Refresh(requestServerRefresh);
			if (IsSelecting)
			{
				RefreshFavorites();
			}
		}
	}
	internal enum RequiredGlobalKeyQueryResult : byte
	{
		Invalid,
		Unavailable,
		PersonalMissing,
		PersonalPresent,
		SharedMissing,
		SharedPresent
	}
	internal static class RequiredGlobalKeyAccess
	{
		private const int SupportedApiVersion = 1;

		private const string ApiTypeName = "YouAreNotWorthy.YouAreNotWorthyApi";

		private static bool _initialized;

		private static bool _youAreNotWorthyInstalled;

		private static bool _apiAvailable;

		private static bool _runtimeFailureLogged;

		private static MethodInfo? _queryLocal;

		private static MethodInfo? _queryPeer;

		private static MethodInfo? _showLocalMissingRequirement;

		internal static bool YouAreNotWorthyInstalled
		{
			get
			{
				EnsureInitialized();
				return _youAreNotWorthyInstalled;
			}
		}

		internal static void Initialize()
		{
			if (_initialized)
			{
				return;
			}
			_initialized = true;
			_youAreNotWorthyInstalled = Chainloader.PluginInfos.TryGetValue("sighsorry.YouAreNotWorthy", out var value);
			if (!_youAreNotWorthyInstalled)
			{
				PortalRulesPlugin.PortalRulesLogger.LogInfo((object)"YouAreNotWorthy is not installed; Required GlobalKeys use shared world progression.");
				return;
			}
			try
			{
				Type type = (((object)value.Instance)?.GetType().Assembly)?.GetType("YouAreNotWorthy.YouAreNotWorthyApi", throwOnError: false, ignoreCase: false);
				FieldInfo fieldInfo = type?.GetField("ApiVersion", BindingFlags.Static | BindingFlags.Public);
				object obj = (((object)fieldInfo != null && fieldInfo.IsLiteral) ? fieldInfo.GetRawConstantValue() : fieldInfo?.GetValue(null));
				int num = ((obj != null) ? Convert.ToInt32(obj, CultureInfo.InvariantCulture) : 0);
				_queryLocal = type?.GetMethod("QueryLocal", BindingFlags.Static | BindingFlags.Public, null, new Type[1] { typeof(string) }, null);
				_queryPeer = type?.GetMethod("QueryPeer", BindingFlags.Static | BindingFlags.Public, null, new Type[2]
				{
					typeof(ZNetPeer),
					typeof(string)
				}, null);
				_showLocalMissingRequirement = type?.GetMethod("TryShowLocalMissingRequirement", BindingFlags.Static | BindingFlags.Public, null, new Type[1] { typeof(string) }, null);
				_apiAvailable = num == 1 && _queryLocal != null && _queryPeer != null;
				if (_apiAvailable)
				{
					PortalRulesPlugin.PortalRulesLogger.LogInfo((object)$"Using YouAreNotWorthy Required GlobalKey API v{num}.");
					if (_showLocalMissingRequirement == null)
					{
						PortalRulesPlugin.PortalRulesLogger.LogWarning((object)"YouAreNotWorthy does not expose its localized missing-requirement message API. Key-gated travel remains fail-closed, but PortalRules will show a generic compatibility message.");
					}
				}
				else
				{
					PortalRulesPlugin.PortalRulesLogger.LogError((object)("YouAreNotWorthy is installed but its Required GlobalKey API is unavailable " + $"or incompatible (found v{num}, expected v{1}). " + "Key-gated portals will fail closed."));
				}
			}
			catch (Exception ex)
			{
				_apiAvailable = false;
				PortalRulesPlugin.PortalRulesLogger.LogError((object)("Could not bind the YouAreNotWorthy Required GlobalKey API; key-gated portals will fail closed: " + ex.GetBaseException().Message));
			}
		}

		internal static void Shutdown()
		{
			_initialized = false;
			_youAreNotWorthyInstalled = false;
			_apiAvailable = false;
			_runtimeFailureLogged = false;
			_queryLocal = null;
			_queryPeer = null;
			_showLocalMissingRequirement = null;
		}

		internal static RequiredGlobalKeyQueryResult QueryLocal(string requiredGlobalKey)
		{
			if (!TryPrepare(requiredGlobalKey, out string normalized))
			{
				return RequiredGlobalKeyQueryResult.Invalid;
			}
			if (normalized.Length == 0)
			{
				return RequiredGlobalKeyQueryResult.SharedPresent;
			}
			EnsureInitialized();
			if (!_youAreNotWorthyInstalled)
			{
				return QuerySharedWorldKey(normalized);
			}
			return Invoke(_queryLocal, new object[1] { normalized });
		}

		internal static RequiredGlobalKeyQueryResult QueryPeer(ZNetPeer? peer, string requiredGlobalKey)
		{
			if (!TryPrepare(requiredGlobalKey, out string normalized))
			{
				return RequiredGlobalKeyQueryResult.Invalid;
			}
			if (normalized.Length == 0)
			{
				return RequiredGlobalKeyQueryResult.SharedPresent;
			}
			EnsureInitialized();
			if (!_youAreNotWorthyInstalled)
			{
				return QuerySharedWorldKey(normalized);
			}
			return Invoke(_queryPeer, new object[2] { peer, normalized });
		}

		internal static bool IsPresent(RequiredGlobalKeyQueryResult result)
		{
			if (result == RequiredGlobalKeyQueryResult.PersonalPresent || result == RequiredGlobalKeyQueryResult.SharedPresent)
			{
				return true;
			}
			return false;
		}

		internal static bool TryShowLocalMissingRequirement(string requiredGlobalKey)
		{
			if (!TryPrepare(requiredGlobalKey, out string normalized) || normalized.Length == 0)
			{
				return false;
			}
			EnsureInitialized();
			if (!_youAreNotWorthyInstalled || !_apiAvailable || _showLocalMissingRequirement == null)
			{
				return false;
			}
			try
			{
				_showLocalMissingRequirement.Invoke(null, new object[1] { normalized });
				return true;
			}
			catch (Exception ex)
			{
				LogRuntimeFailureOnce("YouAreNotWorthy failed to show its missing-requirement message; PortalRules will show a generic compatibility message: " + ex.GetBaseException().Message);
				return false;
			}
		}

		private static bool TryPrepare(string value, out string normalized)
		{
			RequiredGlobalKeyValidationFailure failure;
			return PublicPortalData.TryNormalizeRequiredGlobalKey(value, out normalized, out failure);
		}

		private static RequiredGlobalKeyQueryResult QuerySharedWorldKey(string key)
		{
			ZoneSystem instance = ZoneSystem.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return RequiredGlobalKeyQueryResult.Unavailable;
			}
			string text = default(string);
			GlobalKeys val = default(GlobalKeys);
			string keyValue = ZoneSystem.GetKeyValue(key.ToLowerInvariant(), ref text, ref val);
			string a = default(string);
			if (!instance.GetGlobalKey(keyValue, ref a))
			{
				return RequiredGlobalKeyQueryResult.SharedMissing;
			}
			if (!string.IsNullOrEmpty(text) && !string.Equals(a, text, StringComparison.Ordinal))
			{
				return RequiredGlobalKeyQueryResult.SharedMissing;
			}
			return RequiredGlobalKeyQueryResult.SharedPresent;
		}

		private static RequiredGlobalKeyQueryResult Invoke(MethodInfo? method, object?[] arguments)
		{
			if (!_apiAvailable || method == null)
			{
				return RequiredGlobalKeyQueryResult.Unavailable;
			}
			try
			{
				object obj = method.Invoke(null, arguments);
				int num = ((obj != null) ? Convert.ToInt32(obj, CultureInfo.InvariantCulture) : (-1));
				if (num >= 0 && num <= 255 && Enum.IsDefined(typeof(RequiredGlobalKeyQueryResult), (byte)num))
				{
					byte num2 = (byte)num;
					if (num2 == 1)
					{
						LogRuntimeFailureOnce("YouAreNotWorthy could not resolve a character key snapshot; the affected portal view remains fail-closed until it is available.");
					}
					return (RequiredGlobalKeyQueryResult)num2;
				}
				LogRuntimeFailureOnce($"YouAreNotWorthy returned unknown Required GlobalKey result {num}; " + "the affected portal view remains fail-closed.");
			}
			catch (Exception ex)
			{
				LogRuntimeFailureOnce("YouAreNotWorthy Required GlobalKey query failed; the affected portal view remains fail-closed: " + ex.GetBaseException().Message);
			}
			return RequiredGlobalKeyQueryResult.Unavailable;
		}

		private static void LogRuntimeFailureOnce(string message)
		{
			if (!_runtimeFailureLogged)
			{
				_runtimeFailureLogged = true;
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)message);
			}
		}

		private static void EnsureInitialized()
		{
			if (!_initialized)
			{
				Initialize();
			}
		}
	}
	internal static class PublicPortalModeChangeEffects
	{
		private const string PlayModeChangeEffectRpc = "sighsorry.PortalRules.PlayModeChangeEffect.v1";

		public static void RegisterPeer(ZNet znet, ZNetPeer peer)
		{
			if (!((Object)(object)znet == (Object)null) && peer?.m_rpc != null && !znet.IsServer())
			{
				peer.m_rpc.Register<ZDOID>("sighsorry.PortalRules.PlayModeChangeEffect.v1", (Action<ZRpc, ZDOID>)OnPlayModeChangeEffect);
			}
		}

		public static void Broadcast(ZDOID portalId)
		{
			//IL_0018: 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)
			ZNet instance = ZNet.instance;
			if ((Object)(object)instance == (Object)null || !instance.IsServer())
			{
				return;
			}
			Play(portalId);
			foreach (ZNetPeer peer in instance.GetPeers())
			{
				if (peer.IsReady() && peer.m_rpc != null && peer.m_rpc.IsConnected())
				{
					peer.m_rpc.Invoke("sighsorry.PortalRules.PlayModeChangeEffect.v1", new object[1] { portalId });
				}
			}
		}

		private static void OnPlayModeChangeEffect(ZRpc rpc, ZDOID portalId)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)ZNet.instance == (Object)null) && !ZNet.instance.IsServer() && rpc == ZNet.instance.GetServerRPC())
			{
				Play(portalId);
			}
		}

		private static void Play(ZDOID portalId)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = (((Object)(object)ZNetScene.instance != (Object)null) ? ZNetScene.instance.FindInstance(portalId) : null);
			TeleportWorld val2 = (((Object)(object)val != (Object)null) ? val.GetComponent<TeleportWorld>() : null);
			if (!((Object)(object)val2 == (Object)null) && val2.m_connected != null)
			{
				val2.m_connected.Create(((Component)val2).transform.position, ((Component)val2).transform.rotation, (Transform)null, 1f, -1);
			}
		}
	}
	internal sealed class PublicPortalPinController
	{
		private sealed class PinDecoration
		{
			public readonly GameObject Root;

			public readonly Text MyPortalText;

			public readonly Text FavoriteStar;

			public readonly Text CooldownCross;

			public Image? Icon;

			public Color OriginalIconColor;

			public PinDecoration(GameObject root, Text myPortalText, Text favoriteStar, Text cooldownCross, Image? icon)
			{
				//IL_003f: 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_0044: Unknown result type (might be due to invalid IL or missing references)
				Root = root;
				MyPortalText = myPortalText;
				FavoriteStar = favoriteStar;
				CooldownCross = cooldownCross;
				Icon = icon;
				OriginalIconColor = (((Object)(object)icon != (Object)null) ? ((Graphic)icon).color : Color.white);
			}
		}

		private sealed class TravelBadge
		{
			public readonly GameObject Root;

			public readonly RectTransform RootRect;

			public readonly Image CoinIcon;

			public readonly RectTransform CoinIconRect;

			public readonly Text CostText;

			public readonly RectTransform CostTextRect;

			public readonly Image NoTeleportIcon;

			public TravelBadge(GameObject root, Image coinIcon, Text costText, Image noTeleportIcon)
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Expected O, but got Unknown
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Expected O, but got Unknown
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Expected O, but got Unknown
				Root = root;
				RootRect = (RectTransform)root.transform;
				CoinIcon = coinIcon;
				CoinIconRect = (RectTransform)((Component)coinIcon).transform;
				CostText = costText;
				CostTextRect = (RectTransform)((Component)costText).transform;
				NoTeleportIcon = noTeleportIcon;
			}
		}

		private const float PortalClickRadius = 96f;

		private const float TravelBadgeRefreshIntervalSeconds = 0.2f;

		private const float PinDecorationRefreshIntervalSeconds = 0.2f;

		private const float NoTeleportIconSize = 21f;

		private static readonly Color UnaffordableColor = new Color(1f, 0.42f, 0.32f);

		private static readonly Color CooldownIconColor = new Color(0.42f, 0.42f, 0.42f, 0.82f);

		private static readonly Color CooldownCrossColor = new Color(0.92f, 0.18f, 0.12f);

		private static readonly Color FavoriteStarColor = new Color(1f, 0.76f, 0.2f);

		private const string CooldownPinColorOpen = "<color=#FFAD59>";

		private const string CooldownPinLineMarker = "\n<color=#FFAD59>";

		private static FieldRef<Minimap, float>? LargeZoom = CreateLargeZoomAccessor();

		private readonly Dictionary<PinData, PublicPortalCatalogEntry> _activePins = new Dictionary<PinData, PublicPortalCatalogEntry>();

		private readonly Dictionary<PinData, TravelBadge> _travelBadges = new Dictionary<PinData, TravelBadge>();

		private readonly Dictionary<PinData, PinDecoration> _pinDecorations = new Dictionary<PinData, PinDecoration>();

		private float _nextTravelBadgeRefreshAt = -1f;

		private float _nextPinDecorationRefreshAt = -1f;

		public int Count => _activePins.Count;

		public IEnumerable<PublicPortalCatalogEntry> Portals => _activePins.Values;

		public void Refresh(bool requestServerRefresh = true)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			Clear();
			Minimap instance = Minimap.instance;
			if ((Object)(object)instance == (Object)null)
			{
				if (requestServerRefresh)
				{
					PublicPortalCatalog.RequestRefresh();
				}
				return;
			}
			PublicPortalPinTypeRegistrar.EnsureRegistered(instance);
			foreach (PublicPortalCatalogEntry entry in PublicPortalCatalog.Entries)
			{
				if (PublicPortalAccess.CanUsePortal(entry) && !ShouldHideAdminTaggedPortal(entry))
				{
					string text = BuildPinName(entry);
					PinData val = instance.AddPin(entry.Position, PublicPortalPinTypeRegistrar.PortalPinType, text, false, false, 0L, default(PlatformUserID));
					val.m_doubleSize = false;
					_activePins[val] = entry;
				}
			}
			if (requestServerRefresh)
			{
				PublicPortalCatalog.RequestRefresh();
			}
		}

		private static bool ShouldHideAdminTaggedPortal(PublicPortalCatalogEntry portal)
		{
			if (portal.AccessMode == PublicPortalAccessMode.Tagged && PublicPortalKinds.IsAdminPortalPrefab(portal.PrefabHash))
			{
				return !PortalRulesPlugin.HasAdminDebugAccess;
			}
			return false;
		}

		public void Clear()
		{
			foreach (PinDecoration value in _pinDecorations.Values)
			{
				RestorePinIcon(value);
				if ((Object)(object)value.Root != (Object)null)
				{
					Object.Destroy((Object)(object)value.Root);
				}
			}
			_pinDecorations.Clear();
			_nextPinDecorationRefreshAt = -1f;
			foreach (TravelBadge value2 in _travelBadges.Values)
			{
				if ((Object)(object)value2.Root != (Object)null)
				{
					Object.Destroy((Object)(object)value2.Root);
				}
			}
			_travelBadges.Clear();
			_nextTravelBadgeRefreshAt = -1f;
			if ((Object)(object)Minimap.instance != (Object)null)
			{
				PinData[] array = _activePins.Keys.ToArray();
				foreach (PinData val in array)
				{
					Minimap.instance.RemovePin(val);
				}
			}
			_activePins.Clear();
		}

		public void UpdateTravelBadges(bool isSelecting, PublicPortalCatalogEntry? sourcePortal, bool allowsAllItems)
		{
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			UpdatePinDecorations();
			bool flag = !allowsAllItems && (Object)(object)Player.m_localPlayer != (Object)null && !((Humanoid)Player.m_localPlayer).IsTeleportable();
			if (!isSelecting || !sourcePortal.HasValue || (!PublicPortalTravelCost.IsEnabled && !flag))
			{
				HideTravelBadges();
				_nextTravelBadgeRefreshAt = -1f;
				return;
			}
			float unscaledTime = Time.unscaledTime;
			if (_nextTravelBadgeRefreshAt >= 0f && unscaledTime < _nextTravelBadgeRefreshAt)
			{
				return;
			}
			_nextTravelBadgeRefreshAt = unscaledTime + 0.2f;
			int localCoinCount = (PublicPortalTravelCost.IsEnabled ? PublicPortalTravelCost.GetLocalCoinCount() : 0);
			Sprite sharedCoinIcon = (PublicPortalTravelCost.IsEnabled ? PublicPortalTravelCost.GetCoinIcon() : null);
			foreach (KeyValuePair<PinData, PublicPortalCatalogEntry> activePin in _activePins)
			{
				if (activePin.Value.Id == sourcePortal.Value.Id || InviteTravelCooldownStore.TryGetInviteArrivalCooldownRemaining(activePin.Value, out var _) || (Object)(object)activePin.Key.m_uiElement == (Object)null)
				{
					SetTravelBadgeVisible(activePin.Key, visible: false);
					continue;
				}
				int num = PublicPortalTravelCost.CalculateCost(sourcePortal.Value, activePin.Value);
				if (num <= 0 && !flag)
				{
					SetTravelBadgeVisible(activePin.Key, visible: false);
					continue;
				}
				TravelBadge travelBadge = EnsureTravelBadge(activePin.Key);
				if (travelBadge != null)
				{
					UpdateTravelBadge(travelBadge, num, flag, localCoinCount, sharedCoinIcon);
					if (!travelBadge.Root.activeSelf)
					{
						travelBadge.Root.SetActive(true);
					}
				}
			}
		}

		private void UpdatePinDecorations()
		{
			float unscaledTime = Time.unscaledTime;
			if (_nextPinDecorationRefreshAt >= 0f && unscaledTime < _nextPinDecorationRefreshAt)
			{
				return;
			}
			_nextPinDecorationRefreshAt = unscaledTime + 0.2f;
			HashSet<string> hashSet = new HashSet<string>(PublicPortalData.ReadFavorites(), StringComparer.Ordinal);
			foreach (KeyValuePair<PinData, PublicPortalCatalogEntry> activePin in _activePins)
			{
				PinData key = activePin.Key;
				PublicPortalCatalogEntry value = activePin.Value;
				if (!((Object)(object)key.m_uiElement == (Object)null))
				{
					PinDecoration pinDecoration = EnsurePinDecoration(key);
					bool flag = value.MyPortalOrdinal > 0;
					((Component)pinDecoration.MyPortalText).gameObject.SetActive(flag);
					if (flag)
					{
						Text myPortalText = pinDecoration.MyPortalText;
						string[] array = new string[2];
						int myPortalOrdinal = value.MyPortalOrdinal;
						array[0] = myPortalOrdinal.ToString();
						array[1] = FormatLimit(value.MyPortalLimit);
						myPortalText.text = PortalRulesLocalization.Translate("$sighsorry_portalrules_my_portal_ordinal", array);
					}
					((Component)pinDecoration.FavoriteStar).gameObject.SetActive(hashSet.Contains(value.FavoriteId));
					long remainingSeconds;
					bool flag2 = InviteTravelCooldownStore.TryGetInviteArrivalCooldownRemaining(value, out remainingSeconds);
					UpdatePinIcon(pinDecoration, key.m_iconElement, flag2);
					((Component)pinDecoration.CooldownCross).gameObject.SetActive(flag2);
					UpdateInviteCooldownLine(key, flag2 ? InviteTravelCooldownStore.FormatRemaining(remainingSeconds) : "");
				}
			}
		}

		private PinDecoration EnsurePinDecoration(PinData pin)
		{
			//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_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: 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_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: 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_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Expected O, but got Unknown
			if (_pinDecorations.TryGetValue(pin, out PinDecoration value) && (Object)(object)value.Root != (Object)null)
			{
				if ((Object)(object)value.Root.transform.parent == (Object)(object)pin.m_uiElement)
				{
					return value;
				}
				RestorePinIcon(value);
				Object.Destroy((Object)(object)value.Root);
			}
			GameObject val = new GameObject("PortalRulesPinDecoration", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent((Transform)(object)pin.m_uiElement, false);
			RectTransform val2 = (RectTransform)val.transform;
			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.anchoredPosition = Vector2.zero;
			val2.sizeDelta = Vector2.zero;
			Text myPortalText = CreateDecorationText(val.transform, "MyPortal", 12, (FontStyle)1, Color.white, new Vector2(0f, 25f), new Vector2(190f, 18f));
			Text val3 = CreateDecorationText(val.transform, "FavoriteStar", 14, (FontStyle)1, FavoriteStarColor, Vector2.zero, new Vector2(20f, 20f));
			val3.text = "★";
			Text val4 = CreateDecorationText(val.transform, "InviteCooldownCross", 27, (FontStyle)1, CooldownCrossColor, Vector2.zero, new Vector2(34f, 34f));
			val4.text = "X";
			PinDecoration pinDecoration = new PinDecoration(val, myPortalText, val3, val4, pin.m_iconElement);
			_pinDecorations[pin] = pinDecoration;
			return pinDecoration;
		}

		private static void UpdateInviteCooldownLine(PinData pin, string cooldownText)
		{
			string text = pin.m_name ?? "";
			int num = text.LastIndexOf("\n<color=#FFAD59>", StringComparison.Ordinal);
			string text2 = ((num >= 0) ? text.Substring(0, num) : text);
			string text3 = (string.IsNullOrEmpty(cooldownText) ? text2 : (string.IsNullOrEmpty(text2) ? ("<color=#FFAD59>" + cooldownText + "</color>") : (text2 + "\n<color=#FFAD59>" + cooldownText + "</color>")));
			if (!string.Equals(text, text3, StringComparison.Ordinal))
			{
				pin.m_name = text3;
				PinNameData namePinData = pin.m_NamePinData;
				if ((Object)(object)((namePinData != null) ? namePinData.PinNameText : null) != (Object)null)
				{
					pin.m_NamePinData.PinNameText.text = text3;
				}
			}
		}

		private static Text CreateDecorationText(Transform parent, string name, int fontSize, FontStyle fontStyle, Color color, Vector2 anchoredPosition, Vector2 size)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[3]
			{
				typeof(RectTransform),
				typeof(Text),
				typeof(Outline)
			});
			val.transform.SetParent(parent, false);
			RectTransform val2 = (RectTransform)val.transform;
			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.anchoredPosition = anchoredPosition;
			val2.sizeDelta = size;
			Text component = val.GetComponent<Text>();
			component.font = GUIManager.Instance.AveriaSerif;
			component.fontSize = fontSize;
			component.fontStyle = fontStyle;
			component.alignment = (TextAnchor)4;
			component.horizontalOverflow = (HorizontalWrapMode)1;
			component.verticalOverflow = (VerticalWrapMode)0;
			((Graphic)component).color = color;
			((Graphic)component).raycastTarget = false;
			Outline component2 = val.GetComponent<Outline>();
			((Shadow)component2).effectColor = new Color(0f, 0f, 0f, 0.9f);
			((Shadow)component2).effectDistance = new Vector2(1f, -1f);
			((Shadow)component2).useGraphicAlpha = true;
			return component;
		}

		private static void UpdatePinIcon(PinDecoration decoration, Image? currentIcon, bool cooldownBlocked)
		{
			//IL_002d: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)decoration.Icon != (Object)(object)currentIcon)
			{
				RestorePinIcon(decoration);
				decoration.Icon = currentIcon;
				decoration.OriginalIconColor = (((Object)(object)currentIcon != (Object)null) ? ((Graphic)currentIcon).color : Color.white);
			}
			if ((Object)(object)decoration.Icon != (Object)null)
			{
				((Graphic)decoration.Icon).color = (cooldownBlocked ? CooldownIconColor : decoration.OriginalIconColor);
			}
		}

		private static void RestorePinIcon(PinDecoration decoration)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)decoration.Icon != (Object)null)
			{
				((Graphic)decoration.Icon).color = decoration.OriginalIconColor;
			}
		}

		private static string BuildPinName(PublicPortalCatalogEntry portal)
		{
			string text = SanitizePinLine(portal.Tag);
			string text2 = portal.AccessMode switch
			{
				PublicPortalAccessMode.Invite => BuildModeLine(PublicPortalInteraction.AccessModeLabel(PublicPortalAccessMode.Invite), portal.ModeOrdinal, portal.ModeLimit), 
				PublicPortalAccessMode.Clan => BuildModeLine(PublicPortalInteraction.AccessModeLabel(PublicPortalAccessMode.Clan), portal.ModeOrdinal, portal.ModeLimit), 
				_ => "", 
			};
			if (string.IsNullOrEmpty(text))
			{
				return text2;
			}
			if (!string.IsNullOrEmpty(text2))
			{
				return text + "\n" + text2;
			}
			return text;
		}

		private static string BuildModeLine(string label, int ordinal, int limit)
		{
			if (ordinal <= 0)
			{
				return label;
			}
			return PortalRulesLocalization.Translate("$sighsorry_portalrules_portal_mode_ordinal", label, ordinal.ToString(), FormatLimit(limit));
		}

		private static string FormatLimit(int limit)
		{
			if (limit >= 0)
			{
				return limit.ToString();
			}
			return "∞";
		}

		private static string SanitizePinLine(string? value)
		{
			return StringExtensionMethods.RemoveRichTextTags(value ?? "").Replace('\r', ' ').Replace('\n', ' ')
				.Replace('\t', ' ')
				.Trim();
		}

		private void HideTravelBadges()
		{
			foreach (TravelBadge value in _travelBadges.Values)
			{
				if ((Object)(object)value.Root != (Object)null && value.Root.activeSelf)
				{
					value.Root.SetActive(false);
				}
			}
		}

		private void SetTravelBadgeVisible(PinData pin, bool visible)
		{
			if (_travelBadges.TryGetValue(pin, out TravelBadge value) && (Object)(object)value.Root != (Object)null && value.Root.activeSelf != visible)
			{
				value.Root.SetActive(visible);
			}
		}

		private TravelBadge? EnsureTravelBadge(PinData pin)
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//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_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: 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_02ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0302: Unknown result type (might be due to invalid IL or missing references)
			//IL_0316: Unknown result type (might be due to invalid IL or missing references)
			//IL_0320: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)pin.m_uiElement == (Object)null)
			{
				return null;
			}
			if (_travelBadges.TryGetValue(pin, out TravelBadge value) && (Object)(object)value.Root != (Object)null)
			{
				if ((Object)(object)value.Root.transform.parent == (Object)(object)pin.m_uiElement)
				{
					return value;
				}
				Object.Destroy((Object)(object)value.Root);
			}
			GameObject val = new GameObject("PortalTravelInfo", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent((Transform)(object)pin.m_uiElement, false);
			RectTransform val2 = (RectTransform)val.transform;
			val2.anchorMin = new Vector2(1f, 0.5f);
			val2.anchorMax = new Vector2(1f, 0.5f);
			val2.pivot = new Vector2(0f, 0.5f);
			val2.anchoredPosition = new Vector2(4f, 0f);
			val2.sizeDelta = new Vector2(0f, 20f);
			GameObject val3 = new GameObject("CoinsIcon", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val3.transform.SetParent(val.transform, false);
			RectTransform val4 = (RectTransform)val3.transform;
			val4.anchorMin = new Vector2(0f, 0.5f);
			val4.anchorMax = new Vector2(0f, 0.5f);
			val4.pivot = new Vector2(0f, 0.5f);
			val4.anchoredPosition = Vector2.zero;
			val4.sizeDelta = new Vector2(18f, 18f);
			Image component = val3.GetComponent<Image>();
			component.preserveAspect = true;
			((Graphic)component).raycastTarget = false;
			GameObject val5 = new GameObject("Count", new Type[2]
			{
				typeof(RectTransform),
				typeof(Text)
			});
			val5.transform.SetParent(val.transform, false);
			RectTransform val6 = (RectTransform)val5.transform;
			val6.anchorMin = Vector2.zero;
			val6.anchorMax = Vector2.one;
			val6.offsetMin = new Vector2(22f, 0f);
			val6.offsetMax = Vector2.zero;
			Text component2 = val5.GetComponent<Text>();
			component2.font = GUIManager.Instance.AveriaSerif;
			component2.fontSize = 14;
			component2.fontStyle = (FontStyle)1;
			component2.alignment = (TextAnchor)3;
			component2.horizontalOverflow = (HorizontalWrapMode)1;
			component2.verticalOverflow = (VerticalWrapMode)0;
			((Graphic)component2).raycastTarget = false;
			GameObject val7 = new GameObject("NoTeleport", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val7.transform.SetParent(val.transform, false);
			RectTransform val8 = (RectTransform)val7.transform;
			val8.anchorMin = new Vector2(0f, 0.5f);
			val8.anchorMax = new Vector2(0f, 0.5f);
			val8.pivot = new Vector2(1f, 0f);
			val8.anchoredPosition = new Vector2(-4f, 0f);
			val8.sizeDelta = new Vector2(21f, 21f);
			Image component3 = val7.GetComponent<Image>();
			component3.preserveAspect = true;
			((Graphic)component3).raycastTarget = false;
			val7.SetActive(false);
			TravelBadge travelBadge = new TravelBadge(val, component, component2, component3);
			_travelBadges[pin] = travelBadge;
			return travelBadge;
		}

		private static void UpdateTravelBadge(TravelBadge badge, int travelCost, bool showNoTeleport, int localCoinCount, Sprite? sharedCoinIcon)
		{
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			float num = 0f;
			bool flag = travelCost > 0;
			Sprite val = (flag ? (badge.CoinIcon.sprite ?? sharedCoinIcon) : null);
			bool flag2 = (Object)(object)val != (Object)null;
			((Component)badge.CoinIcon).gameObject.SetActive(flag2);
			if (flag2)
			{
				badge.CoinIcon.sprite = val;
				SetLeftAlignedRect(badge.CoinIconRect, num, 18f);
				num += 22f;
			}
			((Component)badge.CostText).gameObject.SetActive(flag);
			if (flag)
			{
				badge.CostText.text = (flag2 ? PortalRulesLocalization.Translate("$sighsorry_portalrules_quantity", travelCost.ToString()) : PortalRulesLocalization.Translate("$sighsorry_portalrules_coins_quantity", travelCost.ToString()));
				((Graphic)badge.CostText).color = ((localCoinCount >= travelCost) ? Color.white : UnaffordableColor);
				float num2 = Mathf.Ceil(badge.CostText.preferredWidth) + 2f;
				SetLeftAlignedRect(badge.CostTextRect, num, num2);
				num += num2;
			}
			Sprite sprite = null;
			Color color = Color.white;
			Material material = null;
			bool flag3 = showNoTeleport && PublicPortalTravelCost.TryGetNoTeleportVisual(out sprite, out color, out material);
			((Component)badge.NoTeleportIcon).gameObject.SetActive(flag3);
			if (flag3)
			{
				badge.NoTeleportIcon.sprite = sprite;
				((Graphic)badge.NoTeleportIcon).color = color;
				((Graphic)badge.NoTeleportIcon).material = material;
			}
			badge.RootRect.sizeDelta = new Vector2(num, 20f);
		}

		private static void SetLeftAlignedRect(RectTransform rect, float x, float width)
		{
			//IL_000b: 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_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMin = new Vector2(0f, 0.5f);
			rect.anchorMax = new Vector2(0f, 0.5f);
			rect.pivot = new Vector2(0f, 0.5f);
			rect.anchoredPosition = new Vector2(x, 0f);
			rect.sizeDelta = new Vector2(width, 18f);
		}

		public PublicPortalCatalogEntry? FindClosest(Vector3 worldPoint)
		{
			//IL_008a: 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)
			PublicPortalCatalogEntry? result = null;
			float num = float.MaxValue;
			Minimap instance = Minimap.instance;
			float num2 = 1f;
			if ((Object)(object)instance != (Object)null && LargeZoom != null)
			{
				try
				{
					num2 = LargeZoom.Invoke(instance) * 2f;
				}
				catch (Exception ex)
				{
					LargeZoom = null;
					PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("Could not read Minimap.m_largeZoom; portal pin click scaling is disabled: " + ex.Message));
				}
			}
			float num3 = 96f * num2;
			foreach (PublicPortalCatalogEntry value in _activePins.Values)
			{
				float num4 = Utils.DistanceXZ(worldPoint, value.Position);
				if (num4 < num3 && num4 < num)
				{
					result = value;
					num = num4;
				}
			}
			return result;
		}

		private static FieldRef<Minimap, float>? CreateLargeZoomAccessor()
		{
			try
			{
				return AccessTools.FieldRefAccess<Minimap, float>("m_largeZoom");
			}
			catch (Exception ex)
			{
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("Could not bind Minimap.m_largeZoom; portal pin click scaling is disabled: " + ex.Message));
				return null;
			}
		}
	}
	[HarmonyPatch]
	internal static class PublicPortalPinTypeRegistrar
	{
		[HarmonyPatch(typeof(Minimap), "Start")]
		private static class MinimapStartPatch
		{
			private static void Postfix(Minimap __instance)
			{
				EnsureRegistered(__instance);
			}
		}

		private static readonly FieldRef<Minimap, bool[]> VisibleIconTypes = AccessTools.FieldRefAccess<Minimap, bool[]>("m_visibleIconTypes");

		private static PinType _portalPinType = (PinType)3;

		private static Minimap? _registeredMinimap;

		private static Sprite? _portalSprite;

		public static PinType PortalPinType => _portalPinType;

		public static void EnsureRegistered(Minimap minimap)
		{
			//IL_0056: 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_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)minimap == (Object)null) && _registeredMinimap != minimap)
			{
				ref bool[] reference = ref VisibleIconTypes.Invoke(minimap);
				Sprite portalSprite = GetPortalSprite();
				if (!((Object)(object)portalSprite == (Object)null) && reference != null && minimap.m_icons != null)
				{
					int num = reference.Length;
					bool[] array = new bool[num + 1];
					Array.Copy(reference, array, num);
					array[num] = true;
					_portalPinType = (PinType)num;
					reference = array;
					minimap.m_icons.Add(new SpriteData
					{
						m_name = _portalPinType,
						m_icon = portalSprite
					});
					_registeredMinimap = minimap;
				}
			}
		}

		private static Sprite? GetPortalSprite()
		{
			//IL_008e: 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)
			if ((Object)(object)_portalSprite != (Object)null)
			{
				return _portalSprite;
			}
			_portalSprite = FindSprite("teleport_6") ?? FindSprite("teleport_7") ?? FindSprite("mapicon_portal");
			if ((Object)(object)_portalSprite != (Object)null)
			{
				return _portalSprite;
			}
			Texture2D val = FindTexture("teleport_6") ?? FindTexture("teleport_7");
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			_portalSprite = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 100f);
			((Object)_portalSprite).name = "PortalRules Portal Icon";
			return _portalSprite;
		}

		private static Sprite? FindSprite(string name)
		{
			Sprite[] array = Resources.FindObjectsOfTypeAll<Sprite>();
			foreach (Sprite val in array)
			{
				if ((Object)(object)val != (Object)null && ((Object)val).name == name)
				{
					return val;
				}
			}
			return null;
		}

		private static Texture2D? FindTexture(string name)
		{
			Texture2D[] array = Resources.FindObjectsOfTypeAll<Texture2D>();
			foreach (Texture2D val in array)
			{
				if ((Object)(object)val != (Object)null && ((Object)val).name == name)
				{
					return val;
				}
			}
			return null;
		}
	}
	[HarmonyPatch]
	internal static class PublicPortalTaggedConnections
	{
		private delegate void SetConnectionDelegate(Game game, ZDO portal, ZDOID connection, bool forceImmediateConnection);

		[HarmonyPatch(typeof(Game), "ClearCurrentlyConnectingPortals")]
		private static class ClearCrossModeConnectionsPatch
		{
			private static void Postfix(Game __instance)
			{
				//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_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: 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)
				if (!ShouldPartitionConnections() || ZDOMan.instance == null)
				{
					return;
				}
				foreach (ZDO portal in ZDOMan.instance.GetPortals())
				{
					ZDOID connectionZDOID = portal.GetConnectionZDOID((ConnectionType)1);
					if (!(connectionZDOID == ZDOID.None))
					{
						ZDO zDO = ZDOMan.instance.GetZDO(connectionZDOID);
						if (zDO == null || !AreConnectionScopesCompatible(portal, zDO))
						{
							SetConnection(__instance, portal, ZDOID.None, forceImmediateConnection: false);
						}
					}
				}
			}
		}

		[HarmonyPatch(typeof(Game), "FindRandomUnconnectedPortal")]
		private static class FindCompatiblePortalPatch
		{
			private static void Prefix(ref List<ZDO> portals, ZDO skip)
			{
				if (!ShouldPartitionConnections())
				{
					return;
				}
				List<ZDO> list = new List<ZDO>();
				foreach (ZDO portal in portals)
				{
					if (AreConnectionScopesCompatible(skip, portal))
					{
						list.Add(portal);
					}
				}
				portals = list;
			}
		}

		private static readonly SetConnectionDelegate SetConnection = AccessTools.MethodDelegate<SetConnectionDelegate>(AccessTools.DeclaredMethod(typeof(Game), "SetConnection", new Type[3]
		{
			typeof(ZDO),
			typeof(ZDOID),
			typeof(bool)
		}, (Type[])null), (object)null, false);

		internal static void RefreshConnections()
		{
			if (ShouldPartitionConnections() && (Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer() && (Object)(object)Game.instance != (Object)null)
			{
				Game.instance.ConnectPortals();
			}
		}

		private static bool ShouldPartitionConnections()
		{
			return PublicPortalConfig.EnablePortalMap.Value.IsOn();
		}

		private static bool IsTaggedConnectable(ZDO zdo)
		{
			if (zdo != null && PublicPortalKinds.IsHandledPortal(zdo))
			{
				return PublicPortalCatalog.GetEffectiveAccessMode(zdo) == PublicPortalAccessMode.Tagged;
			}
			return false;
		}

		private static bool AreConnectionScopesCompatible(ZDO source, ZDO target)
		{
			bool flag = IsTaggedConnectable(source);
			bool flag2 = IsTaggedConnectable(target);
			if (!flag || !flag2)
			{
				return flag == flag2;
			}
			bool flag3 = PublicPortalKinds.IsAdminPortalPrefab(source.GetPrefab());
			bool flag4 = PublicPortalKinds.IsAdminPortalPrefab(target.GetPrefab());
			if (flag3 || flag4)
			{
				return flag3 && flag4;
			}
			string effectiveAuthorizedClanId = PublicPortalCatalog.GetEffectiveAuthorizedClanId(source);
			string effectiveAuthorizedClanId2 = PublicPortalCatalog.GetEffectiveAuthorizedClanId(target);
			if (effectiveAuthorizedClanId.Length != 0 || effectiveAuthorizedClanId2.Length != 0)
			{
				if (effectiveAuthorizedClanId.Length != 0)
				{
					return string.Equals(effectiveAuthorizedClanId, effectiveAuthorizedClanId2, StringComparison.Ordinal);
				}
				return false;
			}
			PortalOwner effectiveOwner = PublicPortalCatalog.GetEffectiveOwner(source);
			PortalOwner effectiveOwner2 = PublicPortalCatalog.GetEffectiveOwner(target);
			if (effectiveOwner.IsValid && effectiveOwner2.IsValid)
			{
				return string.Equals(effectiveOwner.Id, effectiveOwner2.Id, StringComparison.Ordinal);
			}
			return false;
		}
	}
	internal sealed class PublicPortalFavoritePanel
	{
		private sealed class FavoriteRowPointerHandler : MonoBehaviour, IPointerClickHandler, IEventSystemHandler, IPointerEnterHandler
		{
			private Action? _onRightClick;

			private Action? _onPointerEnter;

			internal void Initialize(Action onRightClick, Action onPointerEnter)
			{
				_onRightClick = onRightClick;
				_onPointerEnter = onPointerEnter;
			}

			public void OnPointerClick(PointerEventData eventData)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Invalid comparison between Unknown and I4
				if ((int)eventData.button == 1)
				{
					((AbstractEventData)eventData).Use();
					_onRightClick?.Invoke();
				}
			}

			public void OnPointerEnter(PointerEventData eventData)
			{
				_onPointerEnter?.Invoke();
			}
		}

		private const float PanelWidth = 320f;

		private const float ExpandedPanelHeight = 420f;

		private const float CollapsedPanelHeight = 46f;

		private const float HeaderHeight = 30f;

		private const float HeaderToggleSize = 26f;

		private const float HeaderToggleGap = 7f;

		private const int ToggleIconPixels = 32;

		private static readonly Color UnaffordableColor = new Color(1f, 0.42f, 0.32f);

		private static readonly Color CooldownRowColor = new Color(0.28f, 0.28f, 0.28f, 0.65f);

		private static readonly Color CooldownLabelColor = new Color(0.68f, 0.68f, 0.68f);

		private static readonly Color CooldownTimeColor = new Color(1f, 0.68f, 0.35f);

		private static readonly Color HeaderToggleColor = new Color(1f, 0.52f, 0.16f, 0.72f);

		private static readonly Color HeaderToggleHoverColor = new Color(1f, 0.68f, 0.28f, 0.96f);

		private static readonly Color HeaderTogglePressedColor = new Color(0.78f, 0.32f, 0.08f, 0.92f);

		private GameObject? _root;

		private Sprite? _collapseIcon;

		private Sprite? _expandIcon;

		public bool IsVisible => (Object)(object)_root != (Object)null;

		public bool IsCollapsed => PublicPortalConfig.FavoritePortalListCollapsed.Value.IsOn();

		public void Refresh(PublicPortalCatalogEntry? sourcePortal, bool itemsBlocked, IEnumerable<PublicPortalCatalogEntry> activePortals, Action<PublicPortalCatalogEntry> onTeleport, Action<PublicPortalCatalogEntry> onRemoveFavorite, Action<PublicPortalCatalogEntry> onHoverPortal)
		{
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			EnsureRoot();
			if ((Object)(object)_root == (Object)null)
			{
				return;
			}
			Transform[] array = ((IEnumerable)_root.transform).Cast<Transform>().ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				Object.Destroy((Object)(object)((Component)array[i]).gameObject);
			}
			bool isCollapsed = IsCollapsed;
			CreateHeader(_root.transform, isCollapsed, ToggleCollapsed);
			SetPanelHeight(isCollapsed);
			if (isCollapsed)
			{
				return;
			}
			List<string> source = PublicPortalData.ReadFavorites();
			Dictionary<string, PublicPortalCatalogEntry> portalsByFavoriteId = new Dictionary<string, PublicPortalCatalogEntry>(StringComparer.Ordinal);
			foreach (PublicPortalCatalogEntry activePortal in activePortals)
			{
				if (!string.IsNullOrEmpty(activePortal.FavoriteId) && !portalsByFavoriteId.ContainsKey(activePortal.FavoriteId))
				{
					portalsByFavoriteId.Add(activePortal.FavoriteId, activePortal);
				}
			}
			List<PublicPortalCatalogEntry> list = (from favoriteId in source.Where(portalsByFavoriteId.ContainsKey)
				select portalsByFavoriteId[favoriteId]).ToList();
			if (list.Count == 0)
			{
				CreateLabel(_root.transform, PortalRulesLocalization.Translate("$sighsorry_portalrules_favorite_portals_empty_hint"), 12, (FontStyle)0);
				return;
			}
			foreach (PublicPortalCatalogEntry item in list)
			{
				PublicPortalCatalogEntry captured = item;
				bool flag = false;
				int travelCost = 0;
				if (sourcePortal.HasValue)
				{
					PublicPortalCatalogEntry value = sourcePortal.Value;
					flag = value.Id != item.Id;
					if (flag)
					{
						travelCost = PublicPortalTravelCost.CalculateCost(value, item);
					}
				}
				long remainingSeconds;
				bool flag2 = InviteTravelCooldownStore.TryGetInviteArrivalCooldownRemaining(item, out remainingSeconds);
				string cooldownText = (flag2 ? InviteTravelCooldownStore.FormatRemaining(remainingSeconds) : "");
				CreateButton(_root.transform, GetPortalDisplayName(item), travelCost, flag && itemsBlocked, flag2, cooldownText, delegate
				{
					onTeleport(captured);
				}, delegate
				{
					onRemoveFavorite(captured);
				}, delegate
				{
					onHoverPortal(captured);
				});
			}
		}

		public void Destroy()
		{
			if ((Object)(object)_root != (Object)null)
			{
				Object.Destroy((Object)(object)_root);
				_root = null;
			}
			DestroyIcon(ref _collapseIcon);
			DestroyIcon(ref _expandIcon);
		}

		private void EnsureRoot()
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected O, but got Unknown
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: 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_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Expected O, but got Unknown
			if (!((Object)(object)_root != (Object)null) && !((Object)(object)Minimap.instance == (Object)null))
			{
				_root = new GameObject("PublicPortalFavorites", new Type[3]
				{
					typeof(RectTransform),
					typeof(Image),
					typeof(VerticalLayoutGroup)
				});
				_root.transform.SetParent(Minimap.instance.m_largeRoot.transform, false);
				RectTransform val = (RectTransform)_root.transform;
				val.anchorMin = new Vector2(0f, 1f);
				val.anchorMax = new Vector2(0f, 1f);
				val.pivot = new Vector2(0f, 1f);
				val.anchoredPosition = new Vector2(24f, -52f);
				val.sizeDelta = new Vector2(320f, 420f);
				((Graphic)_root.GetComponent<Image>()).color = new Color(0f, 0f, 0f, 0.45f);
				VerticalLayoutGroup component = _root.GetComponent<VerticalLayoutGroup>();
				((LayoutGroup)component).padding = new RectOffset(8, 8, 8, 8);
				((HorizontalOrVerticalLayoutGroup)component).spacing = 6f;
				((HorizontalOrVerticalLayoutGroup)component).childForceExpandWidth = true;
				((HorizontalOrVerticalLayoutGroup)component).childForceExpandHeight = false;
				((HorizontalOrVerticalLayoutGroup)component).childControlWidth = true;
				((HorizontalOrVerticalLayoutGroup)component).childControlHeight = true;
			}
		}

		private void CreateHeader(Transform parent, bool collapsed, Action onToggle)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_007f: 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_0095: 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_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Expected O, but got Unknown
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: 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_0128: 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_013d: 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_0148: 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_016c: 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_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Expected O, but got Unknown
			//IL_0231: 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_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("FavoriteHeader", new Type[2]
			{
				typeof(RectTransform),
				typeof(LayoutElement)
			});
			val.transform.SetParent(parent, false);
			val.GetComponent<LayoutElement>().preferredHeight = 30f;
			Text obj = CreateLabel(val.transform, PortalRulesLocalization.Translate("$sighsorry_portalrules_favorite_portals_title"), 14, (FontStyle)1);
			((Graphic)obj).raycastTarget = false;
			RectTransform rectTransform = ((Graphic)obj).rectTransform;
			rectTransform.anchorMin = Vector2.zero;
			rectTransform.anchorMax = Vector2.one;
			rectTransform.offsetMin = Vector2.zero;
			rectTransform.offsetMax = new Vector2(-33f, 0f);
			GameObject val2 = new GameObject("FavoriteListToggle", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(Button)
			});
			val2.transform.SetParent(val.transform, false);
			RectTransform val3 = (RectTransform)val2.transform;
			val3.anchorMin = new Vector2(1f, 0.5f);
			val3.anchorMax = new Vector2(1f, 0.5f);
			val3.pivot = new Vector2(1f, 0.5f);
			val3.anchoredPosition = Vector2.zero;
			val3.sizeDelta = new Vector2(26f, 26f);
			((Graphic)val2.GetComponent<Image>()).color = Color.clear;
			Button component = val2.GetComponent<Button>();
			ColorBlock colors = default(ColorBlock);
			((ColorBlock)(ref colors)).normalColor = HeaderToggleColor;
			((ColorBlock)(ref colors)).highlightedColor = HeaderToggleHoverColor;
			((ColorBlock)(ref colors)).pressedColor = HeaderTogglePressedColor;
			((ColorBlock)(ref colors)).selectedColor = HeaderToggleColor;
			((ColorBlock)(ref colors)).disabledColor = new Color(0.5f, 0.5f, 0.5f, 0.35f);
			((ColorBlock)(ref colors)).colorMultiplier = 1f;
			((ColorBlock)(ref colors)).fadeDuration = 0.08f;
			((Selectable)component).colors = colors;
			((UnityEvent)component.onClick).AddListener((UnityAction)delegate
			{
				onToggle();
			});
			GameObject val4 = new GameObject("Icon", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val4.transform.SetParent(val2.transform, false);
			RectTransform val5 = (RectTransform)val4.transform;
			val5.anchorMin = new Vector2(0.5f, 0.5f);
			val5.anchorMax = new Vector2(0.5f, 0.5f);
			val5.pivot = new Vector2(0.5f, 0.5f);
			val5.anchoredPosition = Vector2.zero;
			val5.sizeDelta = new Vector2(14f, 14f);
			Image component2 = val4.GetComponent<Image>();
			component2.sprite = GetToggleIcon(!collapsed);
			component2.preserveAspect = true;
			((Graphic)component2).raycastTarget = false;
			((Graphic)component2).color = Color.white;
			((Selectable)component).targetGraphic = (Graphic)(object)component2;
			((Graphic)component2).CrossFadeColor(HeaderToggleColor, 0f, true, true);
		}

		private void SetPanelHeight(bool collapsed)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			if (!((Object)(object)_root == (Object)null))
			{
				RectTransform val = (RectTransform)_root.transform;
				val.sizeDelta = new Vector2(320f, collapsed ? 46f : 420f);
				LayoutRebuilder.MarkLayoutForRebuild(val);
			}
		}

		private void ToggleCollapsed()
		{
			PublicPortalConfig.FavoritePortalListCollapsed.Value = ((!IsCollapsed) ? PortalRulesPlugin.Toggle.On : PortalRulesPlugin.Toggle.Off);
		}

		private Sprite GetToggleIcon(bool pointsUp)
		{
			if (pointsUp)
			{
				if (_collapseIcon == null)
				{
					_collapseIcon = CreateToggleIcon(pointsUp: true, "FavoritePortals.Collapse");
				}
				return _collapseIcon;
			}
			if (_expandIcon == null)
			{
				_expandIcon = CreateToggleIcon(pointsUp: false, "FavoritePortals.Expand");
			}
			return _expandIcon;
		}

		private static Sprite CreateToggleIcon(bool pointsUp, string name)
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: 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_00a2: 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_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Expected O, but got Unknown
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			Color32[] array = (Color32[])(object)new Color32[1024];
			int num = 14;
			for (int i = 9; i <= 23; i++)
			{
				float num2 = (float)(i - 9) / (float)num;
				float num3 = (pointsUp ? (1f - num2) : num2);
				int num4 = Mathf.Max(1, Mathf.RoundToInt(9f * num3));
				for (int j = 16 - num4; j <= 16 + num4; j++)
				{
					array[i * 32 + j] = Color32.op_Implicit(Color.white);
				}
			}
			Texture2D val = new Texture2D(32, 32, (TextureFormat)4, false)
			{
				name = name + ".Texture",
				filterMode = (FilterMode)1,
				wrapMode = (TextureWrapMode)1,
				hideFlags = (HideFlags)61
			};
			val.SetPixels32(array);
			val.Apply(false, true);
			Sprite obj = Sprite.Create(val, new Rect(0f, 0f, 32f, 32f), new Vector2(0.5f, 0.5f), 32f, 0u, (SpriteMeshType)0);
			((Object)obj).name = name;
			((Object)obj).hideFlags = (HideFlags)61;
			return obj;
		}

		private static void DestroyIcon(ref Sprite? sprite)
		{
			if (!((Object)(object)sprite == (Object)null))
			{
				Texture2D texture = sprite.texture;
				Object.Destroy((Object)(object)sprite);
				Object.Destroy((Object)(object)texture);
				sprite = null;
			}
		}

		private static string GetPortalDisplayName(PublicPortalCatalogEntry portal)
		{
			string text = SanitizeDisplayLine(portal.Tag);
			if (!string.IsNullOrWhiteSpace(text))
			{
				return text;
			}
			PortalOwner owner = portal.Owner;
			string text2 = SanitizeDisplayLine(owner.Name);
			string text3 = PublicPortalInteraction.AccessModeLabel(portal.AccessMode);
			if (!owner.IsValid || string.IsNullOrWhiteSpace(text2))
			{
				return text3;
			}
			return PortalRulesLocalization.Translate("$sighsorry_portalrules_portal_name_with_owner", text3, text2);
		}

		private static string SanitizeDisplayLine(string? value)
		{
			return StringExtensionMethods.RemoveRichTextTags(value ?? "").Replace('\r', ' ').Replace('\n', ' ')
				.Replace('\t', ' ')
				.Trim();
		}

		private static Text CreateLabel(Transform parent, string text, int fontSize, FontStyle style)
		{
			//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_0044: 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_0090: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Label", new Type[3]
			{
				typeof(RectTransform),
				typeof(Text),
				typeof(LayoutElement)
			});
			val.transform.SetParent(parent, false);
			val.GetComponent<LayoutElement>().preferredHeight = (float)fontSize + 10f;
			Text component = val.GetComponent<Text>();
			component.font = GUIManager.Instance.AveriaSerif;
			component.fontSize = fontSize;
			component.fontStyle = style;
			component.alignment = (TextAnchor)3;
			component.horizontalOverflow = (HorizontalWrapMode)0;
			component.verticalOverflow = (VerticalWrapMode)0;
			((Graphic)component).color = Color.white;
			component.text = text;
			return component;
		}

		private static void CreateButton(Transform parent, string text, int travelCost, bool itemsBlocked, bool cooldownBlocked, string cooldownText, Action onClick, Action onRightClick, Action onPointerEnter)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			//IL_0085: 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_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("PortalButton", new Type[4]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(Button),
				typeof(LayoutElement)
			});
			val.transform.SetParent(parent, false);
			((Graphic)val.GetComponent<Image>()).color = (Color)(cooldownBlocked ? CooldownRowColor : new Color(1f, 1f, 1f, 0.14f));
			val.GetComponent<LayoutElement>().preferredHeight = 30f;
			Button component = val.GetComponent<Button>();
			((UnityEvent)component.onClick).AddListener((UnityAction)delegate
			{
				onClick();
			});
			((Selectable)component).interactable = !cooldownBlocked;
			if (cooldownBlocked)
			{
				((Selectable)component).transition = (Transition)0;
			}
			val.AddComponent<FavoriteRowPointerHandler>().Initialize(onRightClick, onPointerEnter);
			float num = (cooldownBlocked ? CreateCooldownDisplay(val.transform, cooldownText) : ((travelCost > 0 || itemsBlocked) ? CreateTravelInfoDisplay(val.transform, travelCost, itemsBlocked) : 0f));
			Text val2 = CreateLabel(val.transform, text, 12, (FontStyle)0);
			if (cooldownBlocked)
			{
				((Graphic)val2).color = CooldownLabelColor;
			}
			RectTransform val3 = (RectTransform)((Component)val2).transform;
			val3.anchorMin = Vector2.zero;
			val3.anchorMax = Vector2.one;
			val3.offsetMin = new Vector2(8f, 0f);
			val3.offsetMax = new Vector2((num > 0f) ? (0f - (num + 16f)) : (-8f), 0f);
		}

		private static float CreateCooldownDisplay(Transform parent, string cooldownText)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: 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_0071: 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_0090: 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_00ab: Unknown result type (might be due to invalid IL or missing references)
			Text obj = CreateLabel(parent, cooldownText, 12, (FontStyle)1);
			((Object)obj).name = "InviteCooldown";
			obj.alignment = (TextAnchor)5;
			obj.horizontalOverflow = (HorizontalWrapMode)1;
			((Graphic)obj).color = CooldownTimeColor;
			((Graphic)obj).raycastTarget = false;
			float num = Mathf.Ceil(obj.preferredWidth) + 2f;
			RectTransform val = (RectTransform)((Component)obj).transform;
			val.anchorMin = new Vector2(1f, 0.5f);
			val.anchorMax = new Vector2(1f, 0.5f);
			val.pivot = new Vector2(1f, 0.5f);
			val.anchoredPosition = new Vector2(-8f, 0f);
			val.sizeDelta = new Vector2(num, 20f);
			return num;
		}

		private static float CreateTravelInfoDisplay(Transform parent, int travelCost, bool itemsBlocked)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_028a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Expected O, but got Unknown
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Expected O, but got Unknown
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Expected O, but got Unknown
			GameObject val = new GameObject("TravelInfo", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			RectTransform val2 = (RectTransform)val.transform;
			val2.anchorMin = new Vector2(1f, 0.5f);
			val2.anchorMax = new Vector2(1f, 0.5f);
			val2.pivot = new Vector2(1f, 0.5f);
			val2.anchoredPosition = new Vector2(-8f, 0f);
			float num = 0f;
			if (travelCost > 0)
			{
				Sprite coinIcon = PublicPortalTravelCost.GetCoinIcon();
				if ((Object)(object)coinIcon != (Object)null)
				{
					GameObject val3 = new GameObject("CoinsIcon", new Type[2]
					{
						typeof(RectTransform),
						typeof(Image)
					});
					val3.transform.SetParent(val.transform, false);
					SetLeftAlignedRect((RectTransform)val3.transform, num, 20f);
					Image component = val3.GetComponent<Image>();
					component.sprite = coinIcon;
					component.preserveAspect = true;
					((Graphic)component).raycastTarget = false;
					num += 24f;
				}
				string text = (((Object)(object)coinIcon != (Object)null) ? PortalRulesLocalization.Translate("$sighsorry_portalrules_quantity", travelCost.ToString()) : PortalRulesLocalization.Translate("$sighsorry_portalrules_coins_quantity", travelCost.ToString()));
				Text obj = CreateLabel(val.transform, text, 12, (FontStyle)1);
				obj.alignment = (TextAnchor)3;
				obj.horizontalOverflow = (HorizontalWrapMode)1;
				((Graphic)obj).color = ((PublicPortalTravelCost.GetLocalCoinCount() >= travelCost) ? Color.white : UnaffordableColor);
				((Graphic)obj).raycastTarget = false;
				float num2 = Mathf.Ceil(obj.preferredWidth) + 2f;
				SetLeftAlignedRect((RectTransform)((Component)obj).transform, num, num2);
				num += num2;
			}
			if (itemsBlocked && PublicPortalTravelCost.TryGetNoTeleportVisual(out Sprite sprite, out Color color, out Material material))
			{
				if (num > 0f)
				{
					num += 8f;
				}
				GameObject val4 = new GameObject("NoTeleportIcon", new Type[2]
				{
					typeof(RectTransform),
					typeof(Image)
				});
				val4.transform.SetParent(val.transform, false);
				SetLeftAlignedRect((RectTransform)val4.transform, num, 20f);
				Image component2 = val4.GetComponent<Image>();
				component2.sprite = sprite;
				((Graphic)component2).color = color;
				if ((Object)(object)material != (Object)null)
				{
					((Graphic)component2).material = material;
				}
				component2.preserveAspect = true;
				((Graphic)component2).raycastTarget = false;
				num += 20f;
			}
			val2.sizeDelta = new Vector2(num, 22f);
			return num;
		}

		private static void SetLeftAlignedRect(RectTransform rect, float x, float width)
		{
			//IL_000b: 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_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMin = new Vector2(0f, 0.5f);
			rect.anchorMax = new Vector2(0f, 0.5f);
			rect.pivot = new Vector2(0f, 0.5f);
			rect.anchoredPosition = new Vector2(x, 0f);
			rect.sizeDelta = new Vector2(width, 20f);
		}
	}
	internal readonly struct PortalCoinPaymentReceipt
	{
		internal readonly Player? Player;

		internal readonly Inventory? Inventory;

		internal readonly int InventoryCoins;

		internal readonly int PocketCoins;

		internal int TotalCoins => InventoryCoins + PocketCoins;

		internal PortalCoinPaymentReceipt(Player player, Inventory inventory, int inventoryCoins, int pocketCoins)
		{
			Player = player;
			Inventory = inventory;
			InventoryCoins = Math.Max(0, inventoryCoins);
			PocketCoins = Math.Max(0, pocketCoins);
		}
	}
	internal static class PublicPortalTravelCost
	{
		private enum CurrencyPocketState
		{
			Absent,
			Present,
			Unavailable
		}

		private const string CoinPrefabName = "Coins";

		private const string CurrencyPocketCoinDataKey = "CoinPocket_CoinCount";

		private const string CurrencyPocketTypeName = "CurrencyPocket.CurrencyPocket";

		private const string CurrencyPocketUpdateUiMethodName = "UpdatePocketUI";

		private const float DefaultIncludedDistanceMeters = 1000f;

		private const float DefaultCoinsPerKilometer = 5f;

		private static ObjectDB? CachedCoinObjectDb;

		private static ItemData? CachedCoinItemData;

		private static Assembly? CachedCurrencyPocketAssembly;

		private static MethodInfo? CachedCurrencyPocketUpdateUi;

		private static bool CurrencyPocketUpdateUiResolved;

		private static bool CurrencyPocketLookupFailureLogged;

		private static bool CurrencyPocketBalanceFailureLogged;

		private static bool CurrencyPocketUiFailureLogged;

		internal static bool IsEnabled
		{
			get
			{
				PublicPortalTravelCostScope value = PublicPortalConfig.TravelCostScope.Value;
				if ((uint)(value - 1) <= 3u)
				{
					return true;
				}
				return false;
			}
		}

		internal static bool ShouldCharge(int sourcePrefabHash, PublicPortalAccessMode sourceAccessMode, bool sourceAllowsAllItems, int targetPrefabHash, PublicPortalAccessMode targetAccessMode)
		{
			return PublicPortalConfig.TravelCostScope.Value switch
			{
				PublicPortalTravelCostScope.All => true, 
				PublicPortalTravelCostScope.AdminPortalTrips => PublicPortalKinds.IsAdminPortalPrefab(sourcePrefabHash) || PublicPortalKinds.IsAdminPortalPrefab(targetPrefabHash), 
				PublicPortalTravelCostScope.PersonalAndClanRoutesFree => !IsPersonalOrClan(sourceAccessMode) || !IsPersonalOrClan(targetAccessMode), 
				PublicPortalTravelCostScope.AllItemsSourceTrips => sourceAllowsAllItems, 
				_ => false, 
			};
		}

		internal static int CalculateCost(PublicPortalCatalogEntry source, PublicPortalCatalogEntry target)
		{
			//IL_0013: 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 CalculateCost(source.PrefabHash, source.AccessMode, source.AllowsAllItems, source.Position, target.PrefabHash, target.AccessMode, target.Position);
		}

		internal static int CalculateCost(int sourcePrefabHash, PublicPortalAccessMode sourceAccessMode, bool sourceAllowsAllItems, Vector3 sourcePosition, int targetPrefabHash, PublicPortalAccessMode targetAccessMode, Vector3 targetPosition)
		{
			//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)
			if (!ShouldCharge(sourcePrefabHash, sourceAccessMode, sourceAllowsAllItems, targetPrefabHash, targetAccessMode))
			{
				return 0;
			}
			if (!TryGetDistanceXZ(sourcePosition, targetPosition, out var distanceMeters))
			{
				return 0;
			}
			int num = Math.Max(0, PublicPortalConfig.BaseCoinCost.Value);
			double num2 = NonNegativeFiniteOrDefault(PublicPortalConfig.BaseFareIncludedDistanceMeters.Value, 1000f);
			double num3 = NonNegativeFiniteOrDefault(PublicPortalConfig.CoinsPerKilometer.Value, 5f);
			double num4 = Math.Max(0.0, distanceMeters - num2) / 1000.0;
			double num5 = Math.Ceiling(num3 * num4);
			double num6 = (double)num + num5;
			if (!IsFinite(num6) || num6 >= 2147483647.0)
			{
				return int.MaxValue;
			}
			if (!(num6 <= 0.0))
			{
				return (int)num6;
			}
			return 0;
		}

		private static bool IsPersonalOrClan(PublicPortalAccessMode accessMode)
		{
			if (accessMode == PublicPortalAccessMode.Personal || accessMode == PublicPortalAccessMode.Clan)
			{
				return true;
			}
			return false;
		}

		internal static Sprite? GetCoinIcon()
		{
			if (!TryGetCoinItemData(out ItemData coin) || coin.m_shared?.m_icons == null || coin.m_variant < 0 || coin.m_variant >= coin.m_shared.m_icons.Length)
			{
				return null;
			}
			return coin.GetIcon();
		}

		internal static bool TryGetNoTeleportVisual(out Sprite sprite, out Color color, out Material? material)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			InventoryGui instance = InventoryGui.instance;
			object obj;
			if (instance == null)
			{
				obj = null;
			}
			else
			{
				InventoryGrid playerGrid = instance.m_playerGrid;
				if (playerGrid == null)
				{
					obj = null;
				}
				else
				{
					GameObject elementPrefab = playerGrid.m_elementPrefab;
					if (elementPrefab == null)
					{
						obj = null;
					}
					else
					{
						Transform obj2 = elementPrefab.transform.Find("noteleport");
						obj = ((obj2 != null) ? ((Component)obj2).GetComponent<Image>() : null);
					}
				}
			}
			Image val = (Image)obj;
			if ((Object)(object)val == (Object)null || (Object)(object)val.sprite == (Object)null)
			{
				sprite = null;
				color = Color.white;
				material = null;
				return false;
			}
			sprite = val.sprite;
			color = ((Graphic)val).color;
			material = ((Graphic)val).material;
			return true;
		}

		internal static int GetLocalCoinCount()
		{
			if (!TryGetLocalInventoryAndCoinName(out Inventory inventory, out string coinName))
			{
				return 0;
			}
			int num = Math.Max(0, inventory.CountItems(coinName, -1, false));
			Assembly assembly;
			CurrencyPocketState currencyPocketState = GetCurrencyPocketState(out assembly);
			if (currencyPocketState == CurrencyPocketState.Absent)
			{
				return num;
			}
			Player localPlayer = Player.m_localPlayer;
			if (currencyPocketState != CurrencyPocketState.Present || (Object)(object)localPlayer == (Object)null || !TryGetCurrencyPocketBalance(localPlayer, out var balance))
			{
				return 0;
			}
			long num2 = (long)num + (long)balance;
			if (num2 < int.MaxValue)
			{
				return (int)num2;
			}
			return int.MaxValue;
		}

		internal static bool HasLocalCoins(int amount)
		{
			if (amount > 0)
			{
				return GetLocalCoinCount() >= amount;
			}
			return true;
		}

		internal static bool TryConsumeLocalCoins(int amount, out PortalCoinPaymentReceipt receipt)
		{
			receipt = default(PortalCoinPaymentReceipt);
			if (amount <= 0)
			{
				return true;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || !TryGetLocalInventoryAndCoinName(out Inventory inventory, out string coinName))
			{
				return false;
			}
			Assembly assembly;
			return GetCurrencyPocketState(out assembly) switch
			{
				CurrencyPocketState.Present => TryConsumeCurrencyPocketCoins(localPlayer, inventory, coinName, amount, out receipt), 
				CurrencyPocketState.Absent => TryConsumeVanillaCoins(localPlayer, inventory, coinName, amount, out receipt), 
				_ => false, 
			};
		}

		internal static bool TryRefundLocalCoins(in PortalCoinPaymentReceipt receipt)
		{
			if (receipt.TotalCoins <= 0)
			{
				return true;
			}
			Player player = receipt.Player;
			Inventory inventory = receipt.Inventory;
			if ((Object)(object)player == (Object)null || inventory == null || player != Player.m_localPlayer)
			{
				return false;
			}
			if (receipt.PocketCoins <= 0 && GetCurrencyPocketState(out Assembly _) != CurrencyPocketState.Present)
			{
				if (TryRefundPhysicalCoins(inventory, receipt.InventoryCoins, out var restored))
				{
					return restored == receipt.InventoryCoins;
				}
				return false;
			}
			return TryRestoreCurrencyPocketPayment(player, inventory, receipt.InventoryCoins, receipt.PocketCoins);
		}

		private static bool TryConsumeVanillaCoins(Player player, Inventory inventory, string coinName, int amount, out PortalCoinPaymentReceipt receipt)
		{
			receipt = default(PortalCoinPaymentReceipt);
			if (inventory.CountItems(coinName, -1, false) < amount)
			{
				return false;
			}
			int num = inventory.CountItems(coinName, -1, false);
			inventory.RemoveItem(coinName, amount, -1, false);
			int num2 = num - inventory.CountItems(coinName, -1, false);
			if (num2 == amount)
			{
				receipt = new PortalCoinPaymentReceipt(player, inventory, amount, 0);
				return true;
			}
			if (num2 > 0 && (!TryRefundPhysicalCoins(inventory, num2, out var restored) || restored != num2))
			{
				PortalRulesPlugin.PortalRulesLogger.LogError((object)$"Failed to restore {num2} Coins after an incomplete portal fare reservation.");
			}
			return false;
		}

		private static bool TryConsumeCurrencyPocketCoins(Player player, Inventory inventory, string coinName, int amount, out PortalCoinPaymentReceipt receipt)
		{
			receipt = default(PortalCoinPaymentReceipt);
			int num = Math.Max(0, inventory.CountItems(coinName, -1, false));
			if (!TryGetCurrencyPocketBalance(player, out var balance))
			{
				return false;
			}
			if ((long)num + (long)balance < amount)
			{
				return false;
			}
			int num2 = Math.Min(balance, amount);
			int amount2 = amount - num2;
			if (num2 > 0 && !TryRemoveCurrencyPocketCoins(player, num2))
			{
				return false;
			}
			if (!TryRemovePhysicalCoinsExact(inventory, coinName, amount2, out var removed))
			{
				if (!TryRestoreCurrencyPocketPayment(player, inventory, removed, num2))
				{
					PortalRulesPlugin.PortalRulesLogger.LogError((object)$"Failed to restore an incomplete CurrencyPocket fare reservation of {removed + num2} Coins.");
				}
				return false;
			}
			receipt = new PortalCoinPaymentReceipt(player, inventory, removed, num2);
			return true;
		}

		private static bool TryRemovePhysicalCoinsExact(Inventory inventory, string coinName, int amount, out int removed)
		{
			removed = 0;
			if (amount <= 0)
			{
				return true;
			}
			int num = Math.Max(0, inventory.CountItems(coinName, -1, false));
			bool flag = true;
			try
			{
				List<ItemData> list = new List<ItemData>(inventory.GetAllItems());
				int num2 = amount;
				foreach (ItemData item in list)
				{
					if (num2 > 0)
					{
						if (!(item?.m_shared?.m_name != coinName) && item.m_stack > 0)
						{
							int num3 = Math.Min(item.m_stack, num2);
							inventory.RemoveItem(item, num3);
							num2 -= num3;
						}
						continue;
					}
					break;
				}
				flag = num2 == 0;
			}
			catch (Exception ex)
			{
				flag = false;
				PortalRulesPlugin.PortalRulesLogger.LogError((object)("Failed while removing physical Coins for a CurrencyPocket portal fare: " + ex.GetBaseException().Message));
			}
			int num4 = Math.Max(0, inventory.CountItems(coinName, -1, false));
			removed = Math.Max(0, num - num4);
			if (flag)
			{
				return removed == amount;
			}
			return false;
		}

		private static bool TryRefundPhysicalCoins(Inventory inventory, int amount, out int restored)
		{
			restored = 0;
			if (amount <= 0)
			{
				return true;
			}
			if (!TryGetCoinItemData(out ItemData coin) || coin.m_shared == null || string.IsNullOrWhiteSpace(coin.m_shared.m_name))
			{
				return false;
			}
			int num = Math.Max(0, inventory.CountItems(coin.m_shared.m_name, -1, false));
			try
			{
				inventory.AddItem("Coins", amount, coin.m_quality, coin.m_variant, 0L, "", false);
			}
			catch (Exception ex)
			{
				PortalRulesPlugin.PortalRulesLogger.LogError((object)("Failed while restoring physical Coins after a portal fare rollback: " + ex.GetBaseException().Message));
			}
			int num2 = Math.Max(0, inventory.CountItems(coin.m_shared.m_name, -1, false));
			restored = Math.Max(0, num2 - num);
			return restored == amount;
		}

		private static bool TryRestoreCurrencyPocketPayment(Player player, Inventory inventory, int inventoryCoins, int pocketCoins)
		{
			inventoryCoins = Math.Max(0, inventoryCoins);
			pocketCoins = Math.Max(0, pocketCoins);
			int restored;
			bool flag = TryRefundPhysicalCoins(inventory, inventoryCoins, out restored);
			int num = Math.Max(0, inventoryCoins - restored);
			long num2 = (long)pocketCoins + (long)num;
			if (num2 > int.MaxValue)
			{
				return false;
			}
			int num3 = (int)num2;
			bool flag2 = num3 <= 0 || TryAddCurrencyPocketCoins(player, num3);
			if (num > 0 && flag2)
			{
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)$"A portal fare rollback could not return {num} physical Coins to the inventory, so they were restored to CurrencyPocket instead.");
			}
			if (flag2)
			{
				if (!flag)
				{
					return restored + num == inventoryCoins;
				}
				return true;
			}
			return false;
		}

		private static CurrencyPocketState GetCurrencyPocketState(out Assembly assembly)
		{
			if (CachedCurrencyPocketAssembly != null)
			{
				assembly = CachedCurrencyPocketAssembly;
				return CurrencyPocketState.Present;
			}
			try
			{
				if (!Chainloader.PluginInfos.TryGetValue("Azumatt.CurrencyPocket", out var value))
				{
					assembly = null;
					return CurrencyPocketState.Absent;
				}
				if ((Object)(object)value.Instance != (Object)null)
				{
					assembly = ((object)value.Instance).GetType().Assembly;
					CachedCurrencyPocketAssembly = assembly;
					return CurrencyPocketState.Present;
				}
				if (!CurrencyPocketLookupFailureLogged)
				{
					CurrencyPocketLookupFailureLogged = true;
					PortalRulesPlugin.PortalRulesLogger.LogWarning((object)"CurrencyPocket is registered but its plugin instance is unavailable; paid portal travel will fail closed.");
				}
			}
			catch (Exception ex)
			{
				if (!CurrencyPocketLookupFailureLogged)
				{
					CurrencyPocketLookupFailureLogged = true;
					PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("Could not inspect CurrencyPocket; paid portal travel will fail closed: " + ex.GetBaseException().Message));
				}
			}
			assembly = null;
			return CurrencyPocketState.Unavailable;
		}

		private static bool TryGetCurrencyPocketBalance(Player player, out int balance)
		{
			balance = 0;
			if (player != Player.m_localPlayer || GetCurrencyPocketState(out Assembly _) != CurrencyPocketState.Present)
			{
				return false;
			}
			try
			{
				if (!player.m_customData.TryGetValue("CoinPocket_CoinCount", out var value))
				{
					return true;
				}
				if (int.TryParse(value, NumberStyles.Integer, CultureInfo.CurrentCulture, out balance) && balance >= 0)
				{
					return true;
				}
			}
			catch (Exception ex)
			{
				LogCurrencyPocketBalanceFailureOnce(ex.GetBaseException().Message);
				balance = 0;
				return false;
			}
			LogCurrencyPocketBalanceFailureOnce("the saved balance is not a non-negative 32-bit integer");
			balance = 0;
			return false;
		}

		private static bool TryRemoveCurrencyPocketCoins(Player player, int amount)
		{
			if (amount <= 0)
			{
				return true;
			}
			if (TryGetCurrencyPocketBalance(player, out var balance) && balance >= amount)
			{
				return TrySetCurrencyPocketBalance(player, balance - amount);
			}
			return false;
		}

		private static bool TryAddCurrencyPocketCoins(Player player, int amount)
		{
			if (amount <= 0)
			{
				return true;
			}
			if (TryGetCurrencyPocketBalance(player, out var balance) && balance <= int.MaxValue - amount)
			{
				return TrySetCurrencyPocketBalance(player, balance + amount);
			}
			return false;
		}

		private static bool TrySetCurrencyPocketBalance(Player player, int balance)
		{
			if (balance < 0 || player != Player.m_localPlayer || GetCurrencyPocketState(out Assembly _) != CurrencyPocketState.Present)
			{
				return false;
			}
			try
			{
				player.m_customData["CoinPocket_CoinCount"] = balance.ToString(CultureInfo.InvariantCulture);
				RefreshCurrencyPocketUi();
				return true;
			}
			catch (Exception ex)
			{
				LogCurrencyPocketBalanceFailureOnce(ex.GetBaseException().Message);
				return false;
			}
		}

		private static void RefreshCurrencyPocketUi()
		{
			if (GetCurrencyPocketState(out Assembly assembly) != CurrencyPocketState.Present)
			{
				return;
			}
			if (!CurrencyPocketUpdateUiResolved)
			{
				CurrencyPocketUpdateUiResolved = true;
				try
				{
					CachedCurrencyPocketUpdateUi = assembly.GetType("CurrencyPocket.CurrencyPocket", throwOnError: false, ignoreCase: false)?.GetMethod("UpdatePocketUI", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
				}
				catch (Exception ex)
				{
					LogCurrencyPocketUiFailureOnce(ex.GetBaseException().Message);
				}
			}
			if (CachedCurrencyPocketUpdateUi == null)
			{
				LogCurrencyPocketUiFailureOnce("CurrencyPocket.UpdatePocketUI was not found");
				return;
			}
			try
			{
				CachedCurrencyPocketUpdateUi.Invoke(null, null);
			}
			catch (Exception ex2)
			{
				LogCurrencyPocketUiFailureOnce(ex2.GetBaseException().Message);
			}
		}

		private static void LogCurrencyPocketBalanceFailureOnce(string reason)
		{
			if (!CurrencyPocketBalanceFailureLogged)
			{
				CurrencyPocketBalanceFailureLogged = true;
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("CurrencyPocket balance is unavailable; paid portal travel will remain disabled until it is repaired: " + reason));
			}
		}

		private static void LogCurrencyPocketUiFailureOnce(string reason)
		{
			if (!CurrencyPocketUiFailureLogged)
			{
				CurrencyPocketUiFailureLogged = true;
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("Could not refresh the CurrencyPocket display immediately; its saved balance is still correct: " + reason));
			}
		}

		private static bool TryGetDistanceXZ(Vector3 sourcePosition, Vector3 targetPosition, out double distanceMeters)
		{
			//IL_000b: 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_0025: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: 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)
			distanceMeters = 0.0;
			if (!IsFinite(sourcePosition.x) || !IsFinite(sourcePosition.z) || !IsFinite(targetPosition.x) || !IsFinite(targetPosition.z))
			{
				return false;
			}
			double num = (double)targetPosition.x - (double)sourcePosition.x;
			double num2 = (double)targetPosition.z - (double)sourcePosition.z;
			double num3 = num * num + num2 * num2;
			if (!IsFinite(num3) || num3 < 0.0)
			{
				return false;
			}
			distanceMeters = Math.Sqrt(num3);
			return IsFinite(distanceMeters);
		}

		private static double NonNegativeFiniteOrDefault(float value, float fallback)
		{
			return (IsFinite(value) && value >= 0f) ? value : fallback;
		}

		private static bool TryGetLocalInventoryAndCoinName(out Inventory inventory, out string coinName)
		{
			inventory = (((Object)(object)Player.m_localPlayer != (Object)null) ? ((Humanoid)Player.m_localPlayer).GetInventory() : null);
			coinName = "";
			if (inventory == null || !TryGetCoinItemData(out ItemData coin) || coin.m_shared == null || string.IsNullOrWhiteSpace(coin.m_shared.m_name))
			{
				return false;
			}
			coinName = coin.m_shared.m_name;
			return true;
		}

		private static bool TryGetCoinItemData(out ItemData coin)
		{
			coin = null;
			ObjectDB instance = ObjectDB.instance;
			if ((Object)(object)instance == (Object)null)
			{
				CachedCoinObjectDb = null;
				CachedCoinItemData = null;
				return false;
			}
			if (CachedCoinObjectDb == instance && CachedCoinItemData != null)
			{
				coin = CachedCoinItemData;
				return true;
			}
			GameObject itemPrefab = instance.GetItemPrefab("Coins");
			ItemDrop val = (((Object)(object)itemPrefab != (Object)null) ? itemPrefab.GetComponent<ItemDrop>() : null);
			if (val?.m_itemData == null)
			{
				CachedCoinObjectDb = instance;
				CachedCoinItemData = null;
				return false;
			}
			coin = val.m_itemData;
			CachedCoinObjectDb = instance;
			CachedCoinItemData = coin;
			return true;
		}

		private static bool IsFinite(float value)
		{
			if (!float.IsNaN(value))
			{
				return !float.IsInfinity(value);
			}
			return false;
		}

		private static bool IsFinite(double value)
		{
			if (!double.IsNaN(value))
			{
				return !double.IsInfinity(value);
			}
			return false;
		}
	}
	internal enum PortalTravelDenialCode : byte
	{
		None,
		Denied,
		NotReady,
		PortalsBlocked,
		BossBlocked,
		SourceUnavailable,
		SourceAccessDenied,
		DestinationUnavailable,
		DestinationAccessDenied,
		RequiredGlobalKeyMissing,
		RequiredGlobalKeyInvalid,
		RequiredGlobalKeyUnavailable,
		SourceNotTagged,
		TaggedRequiresConnectedDestination,
		SourceTooFar,
		DestinationNotTagged,
		ConnectionChanged,
		DestinationPositionInvalid,
		InviteCooldownDataUnavailable,
		InviteCooldownStorageUnavailable,
		InviteCooldownActive,
		InviteCooldownAccountCapacityReached,
		InviteCooldownPortalCapacityReached,
		InviteCooldownFileCapacityReached,
		InviteCooldownSaveFailed,
		AuthorizationFailed,
		RequestRateLimited
	}
	internal readonly struct PortalTravelDenial
	{
		internal static readonly PortalTravelDenial None = new PortalTravelDenial(PortalTravelDenialCode.None, "", 0L, 0L);

		internal readonly PortalTravelDenialCode Code;

		internal readonly string Argument;

		internal readonly long FirstValue;

		internal readonly long SecondValue;

		internal PortalTravelDenial(PortalTravelDenialCode code, string argument = "", long firstValue = 0L, long secondValue = 0L)
		{
			Code = code;
			Argument = argument ?? "";
			FirstValue = firstValue;
			SecondValue = secondValue;
		}
	}
	internal readonly struct PortalTravelAuthorization
	{
		internal readonly Vector3 TargetPosition;

		internal readonly Quaternion TargetRotation;

		internal readonly int CoinCost;

		internal readonly string AccountId;

		internal readonly string SourceFavoriteId;

		internal readonly string DestinationFavoriteId;

		internal readonly bool UsesInviteAsSource;

		internal readonly bool UsesInviteAsDestination;

		internal readonly InviteTravelCooldownReservation CooldownReservation;

		internal bool RequiresTransaction
		{
			get
			{
				if (CoinCost <= 0)
				{
					return CooldownReservation.IsActive;
				}
				return true;
			}
		}

		internal PortalTravelAuthorization(Vector3 targetPosition, Quaternion targetRotation, int coinCost, string accountId, string sourceFavoriteId, string destinationFavoriteId, bool usesInviteAsSource, bool usesInviteAsDestination, InviteTravelCooldownReservation cooldownReservation)
		{
			//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)
			TargetPosition = targetPosition;
			TargetRotation = targetRotation;
			CoinCost = Math.Max(0, coinCost);
			AccountId = accountId ?? "";
			SourceFavoriteId = sourceFavoriteId ?? "";
			DestinationFavoriteId = destinationFavoriteId ?? "";
			UsesInviteAsSource = usesInviteAsSource;
			UsesInviteAsDestination = usesInviteAsDestination;
			CooldownReservation = cooldownReservation;
		}
	}
	internal static class PublicPortalTeleportService
	{
		private enum TeleportRequestKind
		{
			MapSelection,
			ConnectedPortal,
			MapOpen
		}

		private sealed class PendingRequest
		{
			public readonly long RequestId;

			public readonly ZDOID SourceId;

			public readonly ZDOID TargetId;

			public readonly TeleportRequestKind Kind;

			public readonly bool SourceAllowsAllItems;

			public readonly float ExitDistance;

			public readonly float StartedAt;

			public readonly Action? CompletionAction;

			public PendingRequest(long requestId, ZDOID sourceId, ZDOID targetId, TeleportRequestKind kind, bool sourceAllowsAllItems, float exitDistance, float startedAt, Action? completionAction)
			{
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				RequestId = requestId;
				SourceId = sourceId;
				TargetId = targetId;
				Kind = kind;
				SourceAllowsAllItems = sourceAllowsAllItems;
				ExitDistance = exitDistance;
				StartedAt = startedAt;
				CompletionAction = completionAction;
			}
		}

		private sealed class PendingCommit
		{
			internal readonly string Ticket;

			internal readonly float ExpiresAt;

			internal float NextSendAt;

			internal PendingCommit(string ticket, float now)
			{
				Ticket = ticket;
				ExpiresAt = now + 30f;
				NextSendAt = now;
			}
		}

		private sealed class ServerTravelTicket
		{
			internal readonly string Ticket;

			internal readonly long RequestId;

			internal readonly ZRpc? PeerRpc;

			internal readonly long PeerUid;

			internal readonly string AccountId;

			internal readonly ZDOID SourceId;

			internal readonly ZDOID DestinationId;

			internal readonly string SourceFavoriteId;

			internal readonly string DestinationFavoriteId;

			internal readonly bool UsesInviteAsSource;

			internal readonly bool UsesInviteAsDestination;

			internal readonly int CoinCost;

			internal readonly InviteTravelCooldownReservation CooldownReservation;

			internal float ExpiresAt;

			internal float NextCommitAttemptAt;

			internal bool CommitRequested;

			internal bool Committed;

			internal ServerTravelTicket(string ticket, long requestId, ZRpc? peerRpc, long peerUid, string accountId, ZDOID sourceId, ZDOID destinationId, PortalTravelAuthorization authorization, float now)
			{
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				Ticket = ticket;
				RequestId = requestId;
				PeerRpc = peerRpc;
				PeerUid = peerUid;
				AccountId = accountId;
				SourceId = sourceId;
				DestinationId = destinationId;
				SourceFavoriteId = authorization.SourceFavoriteId;
				DestinationFavoriteId = authorization.DestinationFavoriteId;
				UsesInviteAsSource = authorization.UsesInviteAsSource;
				UsesInviteAsDestination = authorization.UsesInviteAsDestination;
				CoinCost = authorization.CoinCost;
				CooldownReservation = authorization.CooldownReservation;
				ExpiresAt = now + 30f;
				NextCommitAttemptAt = now;
			}
		}

		private const string TeleportRequestRpc = "sighsorry.PortalRules.TeleportRequest.v4";

		private const string TeleportGrantRpc = "sighsorry.PortalRules.TeleportGrant.v4";

		private const string TravelCommitRpc = "sighsorry.PortalRules.TravelCommit.v4";

		private const string TravelCommitAckRpc = "sighsorry.PortalRules.TravelCommitAck.v4";

		private const string TravelCancelRpc = "sighsorry.PortalRules.TravelCancel.v4";

		private const float RequestCooldownSeconds = 0.25f;

		private const float ControlRequestCooldownSeconds = 0.1f;

		private const float PendingRequestTimeoutSeconds = 5f;

		private const float ClientCommitRetrySeconds = 1f;

		private const float ClientCommitRetryLifetimeSeconds = 30f;

		private const float ServerTicketLifetimeSeconds = 30f;

		private const float ServerCommitLifetimeSeconds = 120f;

		private const float CompletedTicketRetentionSeconds = 60f;

		private const float ServerCommitRetrySeconds = 1f;

		private const int TicketRandomByteCount = 24;

		private const int EncodedTicketLength = 32;

		private const int MaximumRequestPackageBytes = 256;

		private const int MaximumControlPackageBytes = 128;

		private const int MaximumServerTickets = 4096;

		private const int MaximumPendingTicketsPerPeer = 4;

		private static readonly Dictionary<ZRpc, float> LastRequestAt = new Dictionary<ZRpc, float>();

		private static readonly Dictionary<ZRpc, long> LastAcceptedRequestId = new Dictionary<ZRpc, long>();

		private static readonly Dictionary<ZRpc, float> LastControlRequestAt = new Dictionary<ZRpc, float>();

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

		private static ZNet? _sessionZNet;

		private static long _nextRequestId;

		private static PendingRequest? _pendingRequest;

		private static PendingCommit? _pendingCommit;

		internal static void BeginNetworkSession(ZNet? znet)
		{
			if (!((Object)(object)znet == (Object)null) && _sessionZNet != znet)
			{
				LastRequestAt.Clear();
				LastAcceptedRequestId.Clear();
				LastControlRequestAt.Clear();
				ClearServerTickets();
				CancelPending();
				_pendingCommit = null;
				_sessionZNet = znet;
			}
		}

		internal static void Shutdown()
		{
			LastRequestAt.Clear();
			LastAcceptedRequestId.Clear();
			LastControlRequestAt.Clear();
			ClearServerTickets();
			CancelPending();
			_pendingCommit = null;
			_sessionZNet = null;
		}

		internal static void RegisterPeer(ZNet znet, ZNetPeer peer)
		{
			if (!((Object)(object)znet == (Object)null) && peer?.m_rpc != null)
			{
				if (znet.IsServer())
				{
					peer.m_rpc.Register<ZPackage>("sighsorry.PortalRules.TeleportRequest.v4", (Action<ZRpc, ZPackage>)OnTeleportRequest);
					peer.m_rpc.Register<ZPackage>("sighsorry.PortalRules.TravelCommit.v4", (Action<ZRpc, ZPackage>)OnTravelCommit);
					peer.m_rpc.Register<ZPackage>("sighsorry.PortalRules.TravelCancel.v4", (Action<ZRpc, ZPackage>)OnTravelCancel);
				}
				else
				{
					peer.m_rpc.Register<ZPackage>("sighsorry.PortalRules.TeleportGrant.v4", (Action<ZRpc, ZPackage>)OnTeleportGrant);
					peer.m_rpc.Register<ZPackage>("sighsorry.PortalRules.TravelCommitAck.v4", (Action<ZRpc, ZPackage>)OnTravelCommitAck);
				}
			}
		}

		internal static void ForgetPeer(ZRpc? rpc)
		{
			if (rpc != null)
			{
				LastRequestAt.Remove(rpc);
				LastAcceptedRequestId.Remove(rpc);
				LastControlRequestAt.Remove(rpc);
				CancelServerTicketsForPeer(rpc);
				if ((Object)(object)ZNet.instance != (Object)null && !ZNet.instance.IsServer() && rpc == ZNet.instance.GetServerRPC())
				{
					CancelPending();
					_pendingCommit = null;
				}
			}
		}

		public static void CancelPending()
		{
			_pendingRequest = null;
		}

		internal static void Tick()
		{
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
			{
				TickServerTickets(realtimeSinceStartup);
			}
			else
			{
				TickClientCommit(realtimeSinceStartup);
			}
			if (_pendingRequest != null && realtimeSinceStartup - _pendingRequest.StartedAt >= 5f)
			{
				_pendingRequest = null;
			}
		}

		public static void TeleportTo(PublicPortalCatalogEntry target, ZDOID sourcePortalId, bool sourceAllowsAllItems, Action endSelection)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null))
			{
				if (!PublicPortalAccess.CanUsePortal(target))
				{
					((Character)localPlayer).Message((MessageType)2, PortalRulesLocalization.Translate("$sighsorry_portalrules_portal_denied"), 0, (Sprite)null);
				}
				else
				{
					BeginTeleportRequest(TeleportRequestKind.MapSelection, sourcePortalId, target.Id, sourceAllowsAllItems, 2f, endSelection);
				}
			}
		}

		internal static void AuthorizeMapOpen(ZDOID sourcePortalId, Action openMap)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!((ZDOID)(ref sourcePortalId)).IsNone() && openMap != null)
			{
				BeginTeleportRequest(TeleportRequestKind.MapOpen, sourcePortalId, ZDOID.None, sourceAllowsAllItems: false, 0f, openMap);
			}
		}

		internal static bool TryBeginConnectedTeleport(TeleportWorld sourcePortal)
		{
			//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_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)
			if ((Object)(object)sourcePortal == (Object)null || !PublicPortalKinds.IsHandledPortal(sourcePortal))
			{
				return false;
			}
			ZDO portalZdo = PublicPortalKinds.GetPortalZdo(sourcePortal);
			if (portalZdo == null)
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)2, PortalRulesLocalization.Translate("$sighsorry_portalrules_portal_data_not_ready"), 0, (Sprite)null);
				}
				return true;
			}
			ZDOID connectionZDOID = portalZdo.GetConnectionZDOID((ConnectionType)1);
			if (((ZDOID)(ref connectionZDOID)).IsNone())
			{
				return true;
			}
			float num = sourcePortal.m_exitDistance;
			if (!IsFinite(num) || num < 0f)
			{
				num = 1f;
			}
			BeginTeleportRequest(TeleportRequestKind.ConnectedPortal, portalZdo.m_uid, connectionZDOID, sourcePortal.m_allowAllItems, num, null);
			return true;
		}

		private static void BeginTeleportRequest(TeleportRequestKind kind, ZDOID sourcePortalId, ZDOID targetPortalId, bool sourceAllowsAllItems, float exitDistance, Action? endSelection)
		{
			//IL_004b: 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_0246: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Expected O, but got Unknown
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: 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_0151: 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)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			if (kind != TeleportRequestKind.MapOpen && !CanTeleportWithItems(sourceAllowsAllItems))
			{
				((Character)localPlayer).Message((MessageType)2, "$msg_noteleport", 0, (Sprite)null);
				return;
			}
			if (_pendingCommit != null)
			{
				((Character)localPlayer).Message((MessageType)2, PortalRulesLocalization.Translate("$sighsorry_portalrules_waiting_for_server"), 0, (Sprite)null);
				return;
			}
			if (PublicPortalCatalog.TryGetClientEntry(sourcePortalId, out var entry) && PublicPortalCatalog.TryGetClientEntry(targetPortalId, out var entry2))
			{
				int num = PublicPortalTravelCost.CalculateCost(entry, entry2);
				if (num > 0 && !PublicPortalTravelCost.HasLocalCoins(num))
				{
					((Character)localPlayer).Message((MessageType)2, PortalRulesLocalization.Translate("$sighsorry_portalrules_need_coins", num.ToString()), 0, (Sprite)null);
					return;
				}
			}
			ZNet instance = ZNet.instance;
			if ((Object)(object)instance == (Object)null)
			{
				((Character)localPlayer).Message((MessageType)2, PortalRulesLocalization.Translate("$sighsorry_portalrules_portal_not_ready"), 0, (Sprite)null);
			}
			else if (instance.IsServer())
			{
				PortalTravelAuthorization authorization = default(PortalTravelAuthorization);
				string text = ((kind == TeleportRequestKind.MapOpen) ? "" : CreateTicket());
				if (kind switch
				{
					TeleportRequestKind.MapOpen => PublicPortalCatalog.TryAuthorizeLocalMapOpen(sourcePortalId, out var denial) ? 1 : 0, 
					TeleportRequestKind.ConnectedPortal => PublicPortalCatalog.TryAuthorizeLocalConnectedTeleport(sourcePortalId, targetPortalId, text, out authorization, out denial) ? 1 : 0, 
					_ => PublicPortalCatalog.TryAuthorizeLocalTeleport(sourcePortalId, targetPortalId, text, out authorization, out denial) ? 1 : 0, 
				} == 0)
				{
					ShowTravelDenial(localPlayer, denial);
					PublicPortalCatalog.RequestRefresh(force: true);
					return;
				}
				if (kind == TeleportRequestKind.MapOpen)
				{
					endSelection?.Invoke();
					return;
				}
				ServerTravelTicket serverTicket = null;
				if (authorization.RequiresTransaction && !TryCreateServerTicket(text, 0L, null, 0L, sourcePortalId, targetPortalId, authorization, out serverTicket))
				{
					InviteTravelCooldownStore.CancelReservation(text);
					ShowTravelDenial(localPlayer, new PortalTravelDenial(PortalTravelDenialCode.AuthorizationFailed, "", 0L, 0L));
					return;
				}
				bool flag = CompleteTeleport(authorization.TargetPosition, authorization.TargetRotation, exitDistance, authorization.CoinCost, kind, sourceAllowsAllItems, endSelection);
				if (serverTicket != null)
				{
					if (!flag)
					{
						CancelServerTicket(serverTicket);
						return;
					}
					serverTicket.CommitRequested = true;
					serverTicket.ExpiresAt = Time.realtimeSinceStartup + 120f;
					TryCommitServerTicket(serverTicket, null);
				}
			}
			else
			{
				ZRpc serverRPC = instance.GetServerRPC();
				if (serverRPC == null || !serverRPC.IsConnected())
				{
					((Character)localPlayer).Message((MessageType)2, PortalRulesLocalization.Translate("$sighsorry_portalrules_server_not_ready"), 0, (Sprite)null);
					return;
				}
				if (_pendingRequest != null && Time.realtimeSinceStartup - _pendingRequest.StartedAt < 5f)
				{
					((Character)localPlayer).Message((MessageType)2, PortalRulesLocalization.Translate("$sighsorry_portalrules_waiting_for_server"), 0, (Sprite)null);
					return;
				}
				CancelPending();
				long num2 = NextRequestId();
				_pendingRequest = new PendingRequest(num2, sourcePortalId, targetPortalId, kind, sourceAllowsAllItems, exitDistance, Time.realtimeSinceStartup, endSelection);
				ZPackage val = new ZPackage();
				val.Write(num2);
				val.Write((int)kind);
				val.Write(sourcePortalId);
				val.Write(targetPortalId);
				serverRPC.Invoke("sighsorry.PortalRules.TeleportRequest.v4", new object[1] { val });
			}
		}

		private static void OnTeleportRequest(ZRpc rpc, ZPackage package)
		{
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			ZNet instance = ZNet.instance;
			if ((Object)(object)instance == (Object)null || !instance.IsServer() || package == null || package.GetArray().Length > 256)
			{
				return;
			}
			ZNetPeer val = PublicPortalData.FindPeer(instance, rpc);
			if (val == null || !val.IsReady())
			{
				return;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			float value;
			bool flag = LastRequestAt.TryGetValue(rpc, out value) && realtimeSinceStartup - value < 0.25f;
			if (!flag)
			{
				LastRequestAt[rpc] = realtimeSinceStartup;
			}
			long num;
			TeleportRequestKind teleportRequestKind;
			ZDOID val2;
			ZDOID val3;
			try
			{
				num = package.ReadLong();
				int num2 = package.ReadInt();
				if (!Enum.IsDefined(typeof(TeleportRequestKind), num2))
				{
					throw new InvalidOperationException($"Unknown portal travel request kind {num2}.");
				}
				teleportRequestKind = (TeleportRequestKind)num2;
				val2 = package.ReadZDOID();
				val3 = package.ReadZDOID();
				if (num <= 0)
				{
					throw new InvalidOperationException("Portal travel request IDs must be positive.");
				}
			}
			catch (Exception ex)
			{
				if (!flag)
				{
					PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("Rejected malformed portal travel request: " + ex.Message));
				}
				return;
			}
			long value2;
			bool flag2 = LastAcceptedRequestId.TryGetValue(rpc, out value2) && num <= value2;
			bool flag3 = false;
			PortalTravelAuthorization authorization = default(PortalTravelAuthorization);
			string text = "";
			PortalTravelDenial denial = new PortalTravelDenial(PortalTravelDenialCode.Denied, "", 0L, 0L);
			if (flag || flag2)
			{
				SendTeleportGrant(rpc, num, teleportRequestKind, success: false, val3, authorization, "", new PortalTravelDenial(PortalTravelDenialCode.RequestRateLimited, "", 0L, 0L));
				return;
			}
			LastAcceptedRequestId[rpc] = num;
			if (teleportRequestKind != TeleportRequestKind.MapOpen)
			{
				text = CreateTicket();
			}
			try
			{
				flag3 = teleportRequestKind switch
				{
					TeleportRequestKind.MapOpen => ((ZDOID)(ref val3)).IsNone() && PublicPortalCatalog.TryAuthorizeMapOpen(val, val2, out denial), 
					TeleportRequestKind.ConnectedPortal => PublicPortalCatalog.TryAuthorizeConnectedTeleport(val, val2, val3, text, out authorization, out denial), 
					_ => PublicPortalCatalog.TryAuthorizeTeleport(val, val2, val3, text, out authorization, out denial), 
				};
			}
			catch (Exception ex2)
			{
				denial = new PortalTravelDenial(PortalTravelDenialCode.AuthorizationFailed, "", 0L, 0L);
				PortalRulesPlugin.PortalRulesLogger.LogError((object)$"Portal travel authorization failed for peer {val.m_uid}: {ex2.Message}");
			}
			if (flag3 && teleportRequestKind != TeleportRequestKind.MapOpen && authorization.RequiresTransaction && !TryCreateServerTicket(text, num, rpc, val.m_uid, val2, val3, authorization, out ServerTravelTicket _))
			{
				InviteTravelCooldownStore.CancelReservation(text);
				flag3 = false;
				authorization = default(PortalTravelAuthorization);
				text = "";
				denial = new PortalTravelDenial(PortalTravelDenialCode.AuthorizationFailed, "", 0L, 0L);
			}
			if (!flag3)
			{
				InviteTravelCooldownStore.CancelReservation(text);
				text = "";
			}
			else if (!authorization.RequiresTransaction)
			{
				text = "";
			}
			SendTeleportGrant(rpc, num, teleportRequestKind, flag3, val3, authorization, text, denial);
		}

		private static void SendTeleportGrant(ZRpc rpc, long requestId, TeleportRequestKind kind, bool success, ZDOID targetPortalId, PortalTravelAuthorization authorization, string ticket, PortalTravelDenial denial)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_001c: 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)
			ZPackage val = new ZPackage();
			val.Write(requestId);
			val.Write((int)kind);
			val.Write(success);
			val.Write(targetPortalId);
			val.Write(authorization.TargetPosition);
			val.Write(authorization.TargetRotation);
			val.Write(authorization.CoinCost);
			val.Write(ticket ?? "");
			val.Write((int)denial.Code);
			val.Write(denial.Argument);
			val.Write(denial.FirstValue);
			val.Write(denial.SecondValue);
			rpc.Invoke("sighsorry.PortalRules.TeleportGrant.v4", new object[1] { val });
		}

		private static void OnTeleportGrant(ZRpc rpc, ZPackage package)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: 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_0116: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ZNet.instance == (Object)null || ZNet.instance.IsServer() || rpc != ZNet.instance.GetServerRPC())
			{
				return;
			}
			try
			{
				long requestId = package.ReadLong();
				int num = package.ReadInt();
				if (!Enum.IsDefined(typeof(TeleportRequestKind), num))
				{
					throw new InvalidOperationException($"Unknown portal travel grant kind {num}.");
				}
				TeleportRequestKind kind = (TeleportRequestKind)num;
				bool success = package.ReadBool();
				ZDOID targetPortalId = package.ReadZDOID();
				Vector3 position = package.ReadVector3();
				Quaternion rotation = package.ReadQuaternion();
				int coinCost = package.ReadInt();
				string text = package.ReadString();
				if (text.Length != 0 && !IsValidTicket(text))
				{
					throw new InvalidOperationException("Portal travel grant contained an invalid ticket.");
				}
				int num2 = package.ReadInt();
				if (num2 < 0 || num2 > 255 || !Enum.IsDefined(typeof(PortalTravelDenialCode), (byte)num2))
				{
					throw new InvalidOperationException($"Unknown portal travel denial code {num2}.");
				}
				PortalTravelDenial denial = new PortalTravelDenial((PortalTravelDenialCode)num2, package.ReadString(), package.ReadLong(), package.ReadLong());
				HandleTeleportGrant(requestId, kind, success, targetPortalId, position, rotation, coinCost, text, denial);
			}
			catch (Exception ex)
			{
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("Ignored malformed portal travel grant: " + ex.Message));
				if (_pendingRequest != null)
				{
					CancelPending();
					Player localPlayer = Player.m_localPlayer;
					if (localPlayer != null)
					{
						((Character)localPlayer).Message((MessageType)2, PortalRulesLocalization.Translate("$sighsorry_portalrules_portal_authorization_failed"), 0, (Sprite)null);
					}
					PublicPortalCatalog.RequestRefresh(force: true);
				}
			}
		}

		private static void HandleTeleportGrant(long requestId, TeleportRequestKind kind, bool success, ZDOID targetPortalId, Vector3 position, Quaternion rotation, int coinCost, string ticket, PortalTravelDenial denial)
		{
			//IL_0015: 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_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			PendingRequest pendingRequest = _pendingRequest;
			if (requestId == 0L || pendingRequest == null || requestId != pendingRequest.RequestId || targetPortalId != pendingRequest.TargetId || kind != pendingRequest.Kind)
			{
				if (ticket.Length > 0 && (_pendingCommit == null || !string.Equals(_pendingCommit.Ticket, ticket, StringComparison.Ordinal)))
				{
					SendTravelCancel(ticket);
				}
				return;
			}
			if (Time.realtimeSinceStartup - pendingRequest.StartedAt >= 5f)
			{
				CancelPending();
				SendTravelCancel(ticket);
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)2, PortalRulesLocalization.Translate("$sighsorry_portalrules_approval_expired"), 0, (Sprite)null);
				}
				PublicPortalCatalog.RequestRefresh(force: true);
				return;
			}
			bool sourceAllowsAllItems = pendingRequest.SourceAllowsAllItems;
			ZDOID sourceId = pendingRequest.SourceId;
			float exitDistance = pendingRequest.ExitDistance;
			Action completionAction = pendingRequest.CompletionAction;
			CancelPending();
			string message;
			if (!success || coinCost < 0 || (kind == TeleportRequestKind.MapOpen && ticket.Length != 0) || (kind != TeleportRequestKind.MapOpen && coinCost > 0 && ticket.Length == 0))
			{
				SendTravelCancel(ticket);
				ShowTravelDenial(Player.m_localPlayer, denial);
				PublicPortalCatalog.RequestRefresh(force: true);
			}
			else if (kind == TeleportRequestKind.MapOpen)
			{
				completionAction?.Invoke();
			}
			else if (!CanCompleteGrantedTeleport(sourceId, out message))
			{
				Player localPlayer2 = Player.m_localPlayer;
				if (localPlayer2 != null)
				{
					((Character)localPlayer2).Message((MessageType)2, message, 0, (Sprite)null);
				}
				SendTravelCancel(ticket);
				PublicPortalCatalog.RequestRefresh(force: true);
			}
			else if (!CompleteTeleport(position, rotation, exitDistance, coinCost, kind, sourceAllowsAllItems, completionAction))
			{
				SendTravelCancel(ticket);
			}
			else if (ticket.Length > 0)
			{
				BeginPendingCommit(ticket);
			}
		}

		private static void BeginPendingCommit(string ticket)
		{
			if (IsValidTicket(ticket))
			{
				_pendingCommit = new PendingCommit(ticket, Time.realtimeSinceStartup);
				TickClientCommit(Time.realtimeSinceStartup);
			}
		}

		private static void TickClientCommit(float now)
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			PendingCommit pendingCommit = _pendingCommit;
			if (pendingCommit == null)
			{
				return;
			}
			if (now >= pendingCommit.ExpiresAt)
			{
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)"The server did not acknowledge the portal fare/travel commit before its retry window expired.");
				_pendingCommit = null;
			}
			else if (!(now < pendingCommit.NextSendAt))
			{
				ZNet instance = ZNet.instance;
				ZRpc val = ((instance != null) ? instance.GetServerRPC() : null);
				if (val == null || !val.IsConnected())
				{
					pendingCommit.NextSendAt = now + 1f;
					return;
				}
				ZPackage val2 = new ZPackage();
				val2.Write(pendingCommit.Ticket);
				val.Invoke("sighsorry.PortalRules.TravelCommit.v4", new object[1] { val2 });
				pendingCommit.NextSendAt = now + 1f;
			}
		}

		private static void SendTravelCancel(string ticket)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			if (IsValidTicket(ticket))
			{
				ZNet instance = ZNet.instance;
				ZRpc val = ((instance != null) ? instance.GetServerRPC() : null);
				if (val != null && val.IsConnected())
				{
					ZPackage val2 = new ZPackage();
					val2.Write(ticket);
					val.Invoke("sighsorry.PortalRules.TravelCancel.v4", new object[1] { val2 });
				}
			}
		}

		private static void OnTravelCommit(ZRpc rpc, ZPackage package)
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || IsControlRequestRateLimited(rpc) || package == null || package.GetArray().Length > 128 || !TryReadTicket(package, out string ticket))
			{
				return;
			}
			if (!ServerTickets.TryGetValue(ticket, out ServerTravelTicket value))
			{
				SendTravelCommitAck(rpc, ticket, committed: false);
			}
			else
			{
				if (!TryAuthenticateTicket(rpc, value, out ZNetPeer peer))
				{
					return;
				}
				if (value.Committed)
				{
					SendTravelCommitAck(rpc, ticket, committed: true);
					return;
				}
				float realtimeSinceStartup = Time.realtimeSinceStartup;
				if (!value.CommitRequested && realtimeSinceStartup >= value.ExpiresAt)
				{
					CancelServerTicket(value);
					SendTravelCommitAck(rpc, ticket, committed: false);
					return;
				}
				if (!value.CommitRequested)
				{
					value.CommitRequested = true;
					value.ExpiresAt = realtimeSinceStartup + 120f;
				}
				TryCommitServerTicket(value, peer);
			}
		}

		private static void OnTravelCancel(ZRpc rpc, ZPackage package)
		{
			if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer() && !IsControlRequestRateLimited(rpc) && package != null && package.GetArray().Length <= 128 && TryReadTicket(package, out string ticket) && ServerTickets.TryGetValue(ticket, out ServerTravelTicket value) && TryAuthenticateTicket(rpc, value, out ZNetPeer _))
			{
				if (value.Committed)
				{
					SendTravelCommitAck(rpc, ticket, committed: true);
				}
				else if (!value.CommitRequested)
				{
					CancelServerTicket(value);
				}
			}
		}

		private static void OnTravelCommitAck(ZRpc rpc, ZPackage package)
		{
			if ((Object)(object)ZNet.instance == (Object)null || ZNet.instance.IsServer() || rpc != ZNet.instance.GetServerRPC())
			{
				return;
			}
			try
			{
				string text = package.ReadString();
				bool flag = package.ReadBool();
				if (IsValidTicket(text) && _pendingCommit != null && string.Equals(_pendingCommit.Ticket, text, StringComparison.Ordinal))
				{
					_pendingCommit = null;
					if (!flag)
					{
						PortalRulesPlugin.PortalRulesLogger.LogWarning((object)"The server rejected the portal fare/travel commit after the teleport had started.");
					}
				}
			}
			catch (Exception ex)
			{
				PortalRulesPlugin.PortalRulesLogger.LogWarning((object)("Ignored malformed portal travel commit acknowledgment: " + ex.Message));
			}
		}

		private static void SendTravelCommitAck(ZRpc rpc, string ticket, bool committed)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			if (rpc != null && rpc.IsConnected() && IsValidTicket(ticket))
			{
				ZPackage val = new ZPackage();
				val.Write(ticket);
				val.Write(committed);
				rpc.Invoke("sighsorry.PortalRules.TravelCommitAck.v4", new object[1] { val });
			}
		}

		private static bool TryCreateServerTicket(string ticket, long requestId, ZRpc? peerRpc, long peerUid, ZDOID sourceId, ZDOID destinationId, PortalTravelAuthorization authorization, out ServerTravelTicket? serverTicket)
		{
			//IL_0037: 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_01ac: 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_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			serverTicket = null;
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			PruneServerTickets(realtimeSinceStartup);
			if (!IsValidTicket(ticket) || ((ZDOID)(ref sourceId)).IsNone() || ((ZDOID)(ref destinationId)).IsNone() || sourceId == destinationId || authorization.CoinCost < 0 || !PublicPortalData.TryNormalizeSteamId64(authorization.AccountId, out string accountId) || !PublicPortalData.TryNormalizeFavoriteId(authorization.SourceFavoriteId, out string normalizedFavoriteId) || !PublicPortalData.TryNormalizeFavoriteId(authorization.DestinationFavoriteId, out string normalizedFavoriteId2) || ServerTickets.ContainsKey(ticket) || ServerTickets.Count >= 4096)
			{
				return false;
			}
			if (authorization.CooldownReservation.IsActive && (!string.Equals(authorization.CooldownReservation.ReservationId, ticket, StringComparison.Ordinal) || !string.Equals(authorization.CooldownReservation.AccountId, accountId, StringComparison.Ordinal) || (authorization.CooldownReservation.RecordsDeparture && (!authorization.UsesInviteAsSource || !string.Equals(authorization.CooldownReservation.SourceFavoriteId, normalizedFavoriteId, StringComparison.Ordinal))) || (authorization.CooldownReservation.RecordsArrival && (!authorization.UsesInviteAsDestination || !string.Equals(authorization.CooldownReservation.DestinationFavoriteId, normalizedFavoriteId2, StringComparison.Ordinal)))))
			{
				return false;
			}
			if (peerRpc != null)
			{
				ZNetPeer val = PublicPortalData.FindPeer(ZNet.instance, peerRpc);
				if (val == null || val.m_uid != peerUid || !val.IsReady() || !PublicPortalData.TryGetPeerSteamId64(val, out string steamId) || !string.Equals(steamId, accountId, StringComparison.Ordinal))
				{
					return false;
				}
			}
			if (ServerTickets.Values.Count((ServerTravelTicket candidate) => !candidate.Committed && ((peerRpc == null) ? (candidate.PeerRpc == null && string.Equals(candidate.AccountId, accountId, StringComparison.Ordinal)) : (candidate.PeerRpc == peerRpc))) >= 4)
			{
				return false;
			}
			serverTicket = new ServerTravelTicket(authorization: new PortalTravelAuthorization(authorization.TargetPosition, authorization.TargetRotation, authorization.CoinCost, accountId, normalizedFavoriteId, normalizedFavoriteId2, authorization.UsesInviteAsSource, authorization.UsesInviteAsDestination, authorization.CooldownReservation), ticket: ticket, requestId: requestId, peerRpc: peerRpc, peerUid: peerUid, accountId: accountId, sourceId: sourceId, destinationId: destinationId, now: realtimeSinceStartup);
			ServerTickets.Add(ticket, serverTicket);
			return true;
		}

		private static bool TryAuthenticateTicket(ZRpc rpc, ServerTravelTicket ticket, out ZNetPeer peer)
		{
			peer = null;
			if (ticket.PeerRpc == null || ticket.PeerRpc != rpc || (Object)(object)ZNet.instance == (Object)null)
			{
				return false;
			}
			ZNetPeer val = PublicPortalData.FindPeer(ZNet.instance, rpc);
			if (val == null || val.m_uid != ticket.PeerUid || !val.IsReady() || !PublicPortalData.TryGetPeerSteamId64(val, out string steamId) || !string.Equals(steamId, ticket.AccountId, StringComparison.Ordinal))
			{
				return false;
			}
			peer = val;
			return true;
		}

		private static bool TryCommitServerTicket(ServerTravelTicket ticket, ZNetPeer? peer)
		{
			//IL_0145: 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)
			if (ticket.Committed)
			{
				if (ticket.PeerRpc != null)
				{
					SendTravelCommitAck(ticket.PeerRpc, ticket.Ticket, committed: true);
				}
				return true;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (!ticket.CommitRequested || realtimeSinceStartup < ticket.NextCommitAttemptAt)
			{
				return false;
			}
			ticket.NextCommitAttemptAt = realtimeSinceStartup + 1f;
			if (ticket.CooldownReservation.IsActive && !InviteTravelCooldownStore.TryCommitReservation(ticket.CooldownReservation, out var failure))
			{
				if ((failure == InviteTravelCooldownFailure.StorageUnavailable || failure == InviteTravelCooldownFailure.SaveFailed) ? true : false)
				{
					return false;
				}
				PortalRulesPlugin.PortalRulesLogger.LogError((object)$"Portal travel commit {ticket.RequestId} could not persist its Invite cooldown: {failure}.");
				ZRpc peerRpc = ticket.PeerRpc;
				string ticket2 = ticket.Ticket;
				CancelServerTicket(ticket);
				if (peerRpc != null)
				{
					SendTravelCommitAck(peerRpc, ticket2, committed: false);
				}
				return false;
			}
			ticket.Committed = true;
			ticket.ExpiresAt = realtimeSinceStartup + 60f;
			if (ticket.CooldownReservation.IsActive)
			{
				if (peer != null)
				{
					PublicPortalCatalog.RefreshCommittedInviteCooldownView(peer);
				}
				else if (ticket.PeerRpc == null)
				{
					PublicPortalCatalog.RefreshCommittedInviteCooldownView(null);
				}
			}
			PortalRulesPlugin.PortalRulesLogger.LogDebug((object)($"Committed portal travel {ticket.RequestId} for SteamID {ticket.AccountId}; " + $"server fare {ticket.CoinCost} Coins, " + $"source {ticket.SourceId}/{ticket.SourceFavoriteId} " + $"(Invite={ticket.UsesInviteAsSource}), destination " + $"{ticket.DestinationId}/{ticket.DestinationFavoriteId} " + $"(Invite={ticket.UsesInviteAsDestination})."));
			if (ticket.PeerRpc != null)
			{
				SendTravelCommitAck(ticket.PeerRpc, ticket.Ticket, committed: true);
			}
			else
			{
				ServerTickets.Remove(ticket.Ticket);
			}
			return true;
		}

		private static void TickServerTickets(float now)
		{
			ServerTravelTicket[] array = ServerTickets.Values.ToArray();
			foreach (ServerTravelTicket serverTravelTicket in array)
			{
				if (serverTravelTicket.Committed)
				{
					if (now >= serverTravelTicket.ExpiresAt)
					{
						ServerTickets.Remove(serverTravelTicket.Ticket);
					}
				}
				else if (now >= serverTravelTicket.ExpiresAt)
				{
					PortalRulesPlugin.PortalRulesLogger.LogWarning((object)(serverTravelTicket.CommitRequested ? $"Portal travel commit {serverTravelTicket.RequestId} expired before its Invite cooldown could be persisted." : $"Uncommitted portal travel reservation {serverTravelTicket.RequestId} expired."));
					ZRpc peerRpc = serverTravelTicket.PeerRpc;
					string ticket = serverTravelTicket.Ticket;
					bool commitRequested = serverTravelTicket.CommitRequested;
					CancelServerTicket(serverTravelTicket);
					if (commitRequested && peerRpc != null)
					{
						SendTravelCommitAck(peerRpc, ticket, committed: false);
					}
				}
				else if (serverTravelTicket.CommitRequested)
				{
					ZNetPeer peer = null;
					if (serverTravelTicket.PeerRpc != null)
					{
						TryAuthenticateTicket(serverTravelTicket.PeerRpc, serverTravelTicket, out peer);
					}
					TryCommitServerTicket(serverTravelTicket, peer);
				}
			}
		}

		private static void PruneServerTickets(float now)
		{
			ServerTravelTicket[] array = ServerTickets.Values.Where((ServerTravelTicket candidate) => now >= candidate.ExpiresAt).ToArray();
			for (int num = 0; num < array.Length; num++)
			{
				CancelServerTicket(array[num]);
			}
		}

		private static void CancelServerTicketsForPeer(ZRpc rpc)
		{
			ServerTravelTicket[] array = ServerTickets.Values.Where((ServerTravelTicket candidate) => candidate.PeerRpc == rpc).ToArray();
			foreach (ServerTravelTicket serverTravelTicket in array)
			{
				if (!serverTravelTicket.CommitRequested || serverTravelTicket.Committed)
				{
					CancelServerTicket(serverTravelTicket);
				}
			}
		}

		private static void ClearServerTickets()
		{
			ServerTravelTicket[] array = ServerTickets.Values.ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				CancelServerTicket(array[i]);
			}
			ServerTickets.Clear();
		}

		private static void CancelServerTicket(ServerTravelTicket ticket)
		{
			if (ServerTickets.Remove(ticket.Ticket) && !ticket.Committed)
			{
				InviteTravelCooldownStore.CancelReservation(ticket.Ticket);
			}
		}

		private static bool TryReadTicket(ZPackage package, out string ticket)
		{
			ticket = "";
			try
			{
				ticket = package.ReadString();
				return IsValidTicket(ticket);
			}
			catch
			{
				ticket = "";
				return false;
			}
		}

		private static bool IsControlRequestRateLimited(ZRpc rpc)
		{
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (LastControlRequestAt.TryGetValue(rpc, out var value) && realtimeSinceStartup - value < 0.1f)
			{
				return true;
			}
			LastControlRequestAt[rpc] = realtimeSinceStartup;
			return false;
		}

		private static bool IsValidTicket(string ticket)
		{
			if (ticket == null || ticket.Length != 32)
			{
				return false;
			}
			try
			{
				return Convert.FromBase64String(ticket).Length == 24;
			}
			catch (FormatException)
			{
				return false;
			}
		}

		private static string CreateTicket()
		{
			byte[] array = new byte[24];
			using RandomNumberGenerator randomNumberGenerator = RandomNumberGenerator.Create();
			for (int i = 0; i < 4; i++)
			{
				randomNumberGenerator.GetBytes(array);
				string text = Convert.ToBase64String(array);
				if (!ServerTickets.ContainsKey(text))
				{
					return text;
				}
			}
			throw new InvalidOperationException("Failed to allocate a unique portal travel ticket.");
		}

		private static void ShowTravelDenial(Player? player, PortalTravelDenial denial)
		{
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			if (denial.Code == PortalTravelDenialCode.RequiredGlobalKeyMissing && PublicPortalData.TryNormalizeRequiredGlobalKey(denial.Argument, out string normalized, out RequiredGlobalKeyValidationFailure _) && normalized.Length > 0)
			{
				if (RequiredGlobalKeyAccess.YouAreNotWorthyInstalled)
				{
					if (!RequiredGlobalKeyAccess.TryShowLocalMissingRequirement(normalized))
					{
						((Character)player).Message((MessageType)2, PortalRulesLocalization.Translate("$sighsorry_portalrules_required_global_key_unavailable"), 0, (Sprite)null);
					}
				}
				else
				{
					((Character)player).Message((MessageType)2, PortalRulesLocalization.Translate("$sighsorry_portalrules_portal_denied") + "\n" + PortalRulesLocalization.Translate("$sighsorry_portalrules_missing_global_key", StringExtensionMethods.RemoveRichTextTags(normalized)), 0, (Sprite)null);
				}
			}
			else
			{
				((Character)player).Message((MessageType)2, GetTravelDenialMessage(denial), 0, (Sprite)null);
			}
		}

		private static string GetTravelDenialMessage(PortalTravelDenial denial)
		{
			string text;
			switch (denial.Code)
			{
			case PortalTravelDenialCode.NotReady:
				text = "$sighsorry_portalrules_portal_not_ready";
				break;
			case PortalTravelDenialCode.PortalsBlocked:
				text = "$msg_blocked";
				break;
			case PortalTravelDenialCode.BossBlocked:
				text = "$msg_blockedbyboss";
				break;
			case PortalTravelDenialCode.SourceUnavailable:
				text = "$sighsorry_portalrules_source_portal_unavailable";
				break;
			case PortalTravelDenialCode.SourceAccessDenied:
				text = "$sighsorry_portalrules_source_portal_denied";
				break;
			case PortalTravelDenialCode.DestinationUnavailable:
				text = "$sighsorry_portalrules_destination_portal_unavailable";
				break;
			case PortalTravelDenialCode.DestinationAccessDenied:
				text = "$sighsorry_portalrules_destination_portal_denied";
				break;
			case PortalTravelDenialCode.RequiredGlobalKeyMissing:
			case PortalTravelDenialCode.RequiredGlobalKeyInvalid:
				text = "$sighsorry_portalrules_required_global_key_invalid";
				break;
			case PortalTravelDenialCode.RequiredGlobalKeyUnavailable:
				text = "$sighsorry_portalrules_required_global_key_unavailable";
				break;
			case PortalTravelDenialCode.SourceNotTagged:
				text = "$sighsorry_portalrules_source_not_tagged";
				break;
			case PortalTravelDenialCode.TaggedRequiresConnectedDestination:
				text = "$sighsorry_portalrules_tagged_uses_connection";
				break;
			case PortalTravelDenialCode.SourceTooFar:
				text = "$sighsorry_portalrules_move_closer_to_source";
				break;
			case PortalTravelDenialCode.DestinationNotTagged:
				text = "$sighsorry_portalrules_destination_not_tagged";
				break;
			case PortalTravelDenialCode.ConnectionChanged:
				text = "$sighsorry_portalrules_connection_changed";
				break;
			case PortalTravelDenialCode.DestinationPositionInvalid:
				text = "$sighsorry_portalrules_destination_position_invalid";
				break;
			case PortalTravelDenialCode.InviteCooldownDataUnavailable:
				text = "$sighsorry_portalrules_invite_cooldown_data_unavailable";
				break;
			case PortalTravelDenialCode.InviteCooldownStorageUnavailable:
				text = "$sighsorry_portalrules_invite_cooldown_storage_unavailable";
				break;
			case PortalTravelDenialCode.InviteCooldownAccountCapacityReached:
				text = "$sighsorry_portalrules_invite_cooldown_account_capacity";
				break;
			case PortalTravelDenialCode.InviteCooldownPortalCapacityReached:
				text = "$sighsorry_portalrules_invite_cooldown_portal_capacity";
				break;
			case PortalTravelDenialCode.InviteCooldownFileCapacityReached:
				text = "$sighsorry_portalrules_invite_cooldown_file_capacity";
				break;
			case PortalTravelDenialCode.InviteCooldownSaveFailed:
				text = "$sighsorry_portalrules_invite_cooldown_save_failed";
				break;
			case PortalTravelDenialCode.AuthorizationFailed:
				text = "$sighsorry_portalrules_portal_authorization_failed";
				break;
			case PortalTravelDenialCode.RequestRateLimited:
				text = "$sighsorry_portalrules_portal_request_rate_limited";
				break;
			default:
				text = "$sighsorry_portalrules_portal_denied";
				break;
			}
			string token = text;
			if (denial.Code != PortalTravelDenialCode.InviteCooldownActive)
			{
				return PortalRulesLocalization.Translate(token);
			}
			string text2 = ((denial.FirstValue > 0) ? InviteTravelCooldownStore.FormatRemaining(denial.FirstValue) : "");
			string text3 = ((denial.SecondValue > 0) ? InviteTravelCooldownStore.FormatRemaining(denial.SecondValue) : "");
			if (text2.Length > 0 && text3.Length > 0)
			{
				return PortalRulesLocalization.Translate("$sighsorry_portalrules_invite_departure_arrival_cooldown", text2, text3);
			}
			if (text2.Length <= 0)
			{
				return PortalRulesLocalization.Translate("$sighsorry_portalrules_invite_arrival_cooldown", (text3.Length > 0) ? text3 : "?");
			}
			return PortalRulesLocalization.Translate("$sighsorry_portalrules_invite_departure_cooldown", text2);
		}

		private static bool CompleteTeleport(Vector3 targetPosition, Quaternion targetRotation, float exitDistance, int coinCost, TeleportRequestKind kind, bool sourceAllowsAllItems, Action? endSelection)
		{
			//IL_0089: 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_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || !CanTeleportWithItems(sourceAllowsAllItems))
			{
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)2, "$msg_noteleport", 0, (Sprite)null);
				}
				return false;
			}
			if (coinCost < 0 || !PublicPortalTravelCost.HasLocalCoins(coinCost))
			{
				((Character)localPlayer).Message((MessageType)2, PortalRulesLocalization.Translate("$sighsorry_portalrules_need_coins", Math.Max(0, coinCost).ToString()), 0, (Sprite)null);
				return false;
			}
			if (!PublicPortalTravelCost.TryConsumeLocalCoins(coinCost, out var receipt))
			{
				((Character)localPlayer).Message((MessageType)2, PortalRulesLocalization.Translate("$sighsorry_portalrules_fare_reservation_failed"), 0, (Sprite)null);
				return false;
			}
			Vector3 val = targetPosition + targetRotation * Vector3.forward * exitDistance + Vector3.up;
			bool flag;
			try
			{
				flag = ((Character)localPlayer).TeleportTo(val, targetRotation, true);
			}
			catch (Exception arg)
			{
				RefundReservedFare(in receipt);
				PortalRulesPlugin.PortalRulesLogger.LogError((object)$"Portal travel failed while starting the teleport: {arg}");
				((Character)localPlayer).Message((MessageType)2, PortalRulesLocalization.Translate("$sighsorry_portalrules_teleport_start_failed"), 0, (Sprite)null);
				return false;
			}
			if (!flag)
			{
				RefundReservedFare(in receipt);
				((Character)localPlayer).Message((MessageType)2, PortalRulesLocalization.Translate("$sighsorry_portalrules_teleport_start_failed"), 0, (Sprite)null);
				return false;
			}
			try
			{
				endSelection?.Invoke();
			}
			catch (Exception arg2)
			{
				PortalRulesPlugin.PortalRulesLogger.LogError((object)$"Portal travel started, but its selection cleanup failed: {arg2}");
			}
			if (kind == TeleportRequestKind.MapSelection)
			{
				try
				{
					Minimap instance = Minimap.instance;
					if (instance != null)
					{
						instance.SetMapMode((MapMode)1);
					}
				}
				catch (Exception arg3)
				{
					PortalRulesPlugin.PortalRulesLogger.LogError((object)$"Portal travel started, but closing the map failed: {arg3}");
				}
			}
			try
			{
				Game instance2 = Game.instance;
				if (instance2 != null)
				{
					instance2.IncrementPlayerStat((PlayerStatType)15, 1f);
				}
			}
			catch (Exception arg4)
			{
				PortalRulesPlugin.PortalRulesLogger.LogError((object)$"Portal travel started, but updating the portal-use statistic failed: {arg4}");
			}
			return true;
		}

		private static void RefundReservedFare(in PortalCoinPaymentReceipt receipt)
		{
			if (!PublicPortalTravelCost.TryRefundLocalCoins(in receipt))
			{
				PortalRulesPlugin.PortalRulesLogger.LogError((object)$"Portal travel did not start and restoring the reserved {receipt.TotalCoins} Coins failed.");
			}
		}

		private static bool CanCompleteGrantedTeleport(ZDOID sourcePortalId, out string message)
		{
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: 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_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || ((ZDOID)(ref sourcePortalId)).IsNone() || ZDOMan.instance == null)
			{
				message = PortalRulesLocalization.Translate("$sighsorry_portalrules_portal_no_longer_ready");
				return false;
			}
			if ((Object)(object)ZoneSystem.instance == (Object)null)
			{
				message = PortalRulesLocalization.Translate("$sighsorry_portalrules_portal_no_longer_ready");
				return false;
			}
			if (ZoneSystem.instance.GetGlobalKey((GlobalKeys)27))
			{
				message = "$msg_blocked";
				return false;
			}
			if (ZoneSystem.instance.GetGlobalKey((GlobalKeys)28))
			{
				RandEventSystem instance = RandEventSystem.instance;
				float num = default(float);
				if (((instance != null) ? instance.GetBossEvent() : null) != null || (ZoneSystem.instance.GetGlobalKey((GlobalKeys)38, ref num) && num > 0f))
				{
					message = "$msg_blockedbyboss";
					return false;
				}
			}
			ZDO zDO = ZDOMan.instance.GetZDO(sourcePortalId);
			Vector3 position = ((Component)localPlayer).transform.position;
			Vector3 val = ((zDO != null) ? zDO.GetPosition() : Vector3.positiveInfinity);
			if (zDO == null || !zDO.IsValid() || !PublicPortalKinds.IsHandledPortal(zDO) || !IsFinite(position) || !IsFinite(val) || Vector3.Distance(position, val) > 15f)
			{
				message = PortalRulesLocalization.Translate("$sighsorry_portalrules_move_closer_to_source_retry");
				return false;
			}
			message = "";
			return true;
		}

		private static bool IsFinite(Vector3 value)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (IsFinite(value.x) && IsFinite(value.y))
			{
				return IsFinite(value.z);
			}
			return false;
		}

		private static bool IsFinite(float value)
		{
			if (!float.IsNaN(value))
			{
				return !float.IsInfinity(value);
			}
			return false;
		}

		private static bool CanTeleportWithItems(bool sourceAllowsAllItems)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return false;
			}
			if (!sourceAllowsAllItems)
			{
				return ((Humanoid)localPlayer).IsTeleportable();
			}
			return true;
		}

		private static long NextRequestId()
		{
			_nextRequestId++;
			if (_nextRequestId == 0L)
			{
				_nextRequestId++;
			}
			return _nextRequestId;
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[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 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;
		}
	}
}